void
MyMFCC::myUpdate(MarControlPtr sender)
{
static const double fh = 0.5;
static const double fl = 0;
mrs_natural filterCount = inObservations_;
//mrs_natural filterCount = getControl("mrs_natural/coefficients")->to<mrs_natural>();
//mrs_natural windowSize = 2 * (inObservations_ - 1);
//mrs_real sampleRate = israte_ * windowSize;
if (filterCount < 1 ) //|| windowSize < 1)
{
// skip unnecessary updates
m_filterCount = filterCount;
//m_win = windowSize;
//m_sr = sampleRate;
return;
}
//cout << "*** MyMFCC: sampleRate = " << sampleRate << endl;
/*
if (filterCount != m_filterCount || windowSize != m_win || sampleRate != m_sr)
{
initMelFilters(filterCount, windowSize, sampleRate, fl, fh);
}
*/
if (filterCount != m_filterCount)
{
fftwf_free(m_dctIn);
fftwf_free(m_dctOut);
fftwf_destroy_plan(m_plan);
m_dctIn = fftwf_alloc_real(filterCount);
m_dctOut = fftwf_alloc_real(filterCount);
m_plan = fftwf_plan_r2r_1d(filterCount, m_dctIn, m_dctOut,
FFTW_REDFT10, FFTW_ESTIMATE);
}
/*
if ( windowSize != m_win )
{
m_buf.allocate( inObservations_ );
}
*/
setControl("mrs_natural/onObservations", filterCount);
setControl("mrs_natural/onSamples", inSamples_);
m_filterCount = filterCount;
//m_win = windowSize;
//m_sr = sampleRate;
}
LV2_Handle PitchShifter::instantiate(const LV2_Descriptor* descriptor, double samplerate, const char* bundle_path, const LV2_Feature* const* features)
{
PitchShifter *plugin = new PitchShifter();
plugin->nBuffers = 20;
plugin->Qcolumn = plugin->nBuffers;
plugin->hopa = TAMANHO_DO_BUFFER;
plugin->N = plugin->nBuffers*plugin->hopa;
plugin->cont = 0;
plugin->s = 0;
plugin->g = 1;
plugin->Hops = (int*)calloc(plugin->Qcolumn,sizeof(int)); memset(plugin->Hops, plugin->hopa, plugin->Qcolumn );
plugin->frames = (double*)calloc(plugin->N,sizeof(double));
plugin->ysaida = (double*)calloc(2*(plugin->N + 2*(plugin->Qcolumn-1)*plugin->hopa),sizeof(double));
plugin->yshift = (double*)calloc(plugin->hopa,sizeof(double));
plugin->b = (double**)calloc(plugin->hopa,sizeof(double*));
plugin->frames2 = fftwf_alloc_real(plugin->N);
plugin->q = fftwf_alloc_real(plugin->N);
plugin->fXa = fftwf_alloc_complex(plugin->N/2 + 1);
plugin->fXs = fftwf_alloc_complex(plugin->N/2 + 1);
plugin->Xa.zeros(plugin->N/2 + 1);
plugin->Xs.zeros(plugin->N/2 + 1);
plugin->XaPrevious.zeros(plugin->N/2 + 1);
plugin->Xa_arg.zeros(plugin->N/2 + 1);
plugin->XaPrevious_arg.zeros(plugin->N/2 + 1);
plugin->Phi.zeros(plugin->N/2 + 1);
plugin->PhiPrevious.zeros(plugin->N/2 + 1);
plugin->d_phi.zeros(plugin->N/2 + 1);
plugin->d_phi_prime.zeros(plugin->N/2 + 1);
plugin->d_phi_wrapped.zeros(plugin->N/2 + 1);
plugin->omega_true_sobre_fs.zeros(plugin->N/2 + 1);
plugin->AUX.zeros(plugin->N/2 + 1);
plugin->Xa_abs.zeros(plugin->N/2 + 1);
plugin->w.zeros(plugin->N); hann(plugin->N,&plugin->w);
plugin->I.zeros(plugin->N/2 + 1); plugin->I = linspace(0, plugin->N/2,plugin->N/2 + 1);
for (int i=1 ; i<= (plugin->nBuffers); i++)
{
plugin->b[i-1] = &plugin->frames[(i-1)*plugin->hopa];
}
plugin->p = fftwf_plan_dft_r2c_1d(plugin->N, plugin->frames2, plugin->fXa, FFTW_ESTIMATE);
plugin->p2 = fftwf_plan_dft_c2r_1d(plugin->N, plugin->fXs, plugin->q, FFTW_ESTIMATE);
return (LV2_Handle)plugin;
}
float*
FFTW::alloc_real<float>(size_t n) {
assert(n > 0);
float* p = fftwf_alloc_real(n);
if (p == nullptr) THROW_EXCEPTION(FFTWException, "Error in fftw_alloc_real (float, n = " << n << ").");
return p;
}
PSSinthesis::PSSinthesis(PSAnalysis *obj, const char* wisdomFile) //Construtor
{
Qcolumn = obj->Qcolumn;
hopa = obj->hopa;
N = obj->N;
omega_true_sobre_fs = &obj->omega_true_sobre_fs;
Xa_abs = &obj->Xa_abs;
w = &obj->w;
first = true;
hops = new int[Qcolumn]; fill_n(hops,Qcolumn,hopa);
ysaida = new double[2*N + 4*(Qcolumn-1)*hopa]; fill_n(ysaida,2*N + 4*(Qcolumn-1)*hopa,0);
yshift = new double[hopa]; fill_n(yshift,hopa,0);
q = fftwf_alloc_real(N);
fXs = fftwf_alloc_complex(N/2 + 1);
Xs.zeros(N/2 + 1);
Phi.zeros(N/2 + 1);
PhiPrevious.zeros(N/2 + 1);
if (fftwf_import_wisdom_from_filename(wisdomFile) != 0)
{
p2 = fftwf_plan_dft_c2r_1d(N, fXs, q, FFTW_WISDOM_ONLY);
}
else
{
p2 = NULL;
printf("PSSinthesis: failed to import wisdom file '%s'\n", wisdomFile);
}
}
int main(){
int nthreads = 4;
omp_set_num_threads(nthreads);
#pragma omp parallel
fprintf(stderr,"nthreads %d \n", omp_get_num_threads());
int n3 = 128;
int n2 = 128;
int n1 = 128;
// float ***array = sf_floatalloc3(n1,n2,n3);
float *array = fftwf_alloc_real(n3*n2*n1);
fftwf_complex* cout = fftwf_alloc_complex(n3*n2*n1);
int err = fftwf_init_threads();
if (err == 0) {
fprintf(stderr,"something went wrong with fftw\n");
}
fprintf(stderr,"Got here\n");
double start,end;
start = omp_get_wtime()*omp_get_wtick();
fftwf_plan_with_nthreads(nthreads);
fftwf_plan plan = fftwf_plan_dft_r2c_3d(
n1,n2,n3,
array,cout,
FFTW_MEASURE);
end = omp_get_wtime()*omp_get_wtick();
fprintf(stderr,"elapsed time: %f %f %f\n",end,start,end-start);
for(int i = 0; i < n3*n2*n1; ++i)
array[i] = rand()/RAND_MAX;
//float start = clock()/CLOCKS_PER_SEC;
start = omp_get_wtime();
for(int i=0; i < 1001; ++i)
fftwf_execute(plan);
//float end = clock()/CLOCKS_PER_SEC;
end = omp_get_wtime();
fprintf(stderr,"elapsed time: %f time/calc %f\n",
end-start,(end-start)/100.0);
fftwf_cleanup_threads();
fftwf_cleanup();
fftwf_destroy_plan(plan);
fftwf_free(cout);
fftwf_free(array);
//free(**array); free(*array); free(array);
return 0;
}
PitchDetection::PitchDetection(uint32_t n_samples, int nBuffers, double SampleRate, const char* wisdomFile) //Constructor
{
hopa = n_samples;
N = nBuffers*n_samples;
fs = SampleRate;
frames = fftwf_alloc_real(2*N); memset(frames, 0, 2*N );
b = new float*[hopa];
for (int i=0 ; i< nBuffers; i++)
{
b[i] = &frames[i*hopa];
}
q = fftwf_alloc_real(2*N);
fXa = fftwf_alloc_complex(N + 1);
fXs = fftwf_alloc_complex(N + 1);
Xa.zeros(N + 1);
Xs.zeros(N + 1);
R.zeros(N);
NORM.zeros(N);
F.zeros(N);
AUTO.zeros(N);
if (fftwf_import_wisdom_from_filename(wisdomFile) != 0)
{
p = fftwf_plan_dft_r2c_1d(2*N, frames, fXa, FFTW_WISDOM_ONLY);
p2 = fftwf_plan_dft_c2r_1d(2*N, fXs, q, FFTW_WISDOM_ONLY);
}
else
{
p = fftwf_plan_dft_r2c_1d(2*N, frames, fXa, FFTW_ESTIMATE);
p2 = fftwf_plan_dft_c2r_1d(2*N, fXs, q, FFTW_ESTIMATE);
printf("PitchDetection: failed to import wisdom file '%s', using estimate instead\n", wisdomFile);
}
}
PowerSpectrum( int windowSize ):
m_windowSize(windowSize)
{
m_inBuffer = fftwf_alloc_real(windowSize);
m_outBuffer = fftwf_alloc_real(windowSize);
m_plan = fftwf_plan_r2r_1d(windowSize, m_inBuffer, m_outBuffer,
FFTW_R2HC, FFTW_ESTIMATE);
double pi = Segmenter::pi();
m_window = new float[windowSize];
float sumWindow = 0.f;
for (int idx=0; idx < windowSize; ++idx) {
// hamming window:
m_window[idx] = 0.54 - 0.46 * std::cos(2 * pi * idx / (windowSize-1) );
sumWindow += m_window[idx];
}
m_outputScale = 2.f / sumWindow;
m_outputScale *= m_outputScale; // square, because we'll be multiplying power instead of raw spectrum
m_output.resize(windowSize / 2 + 1);
}
PSAnalysis::PSAnalysis(uint32_t n_samples, int nBuffers, const char* wisdomFile) //Construtor
{
Qcolumn = nBuffers;
hopa = n_samples;
N = nBuffers*n_samples;
frames = new double[N]; fill_n(frames,N,0);
b = new double*[hopa];
for (int i=0 ; i< nBuffers; i++)
b[i] = &frames[i*hopa];
frames2 = fftwf_alloc_real(N);
fXa = fftwf_alloc_complex(N/2 + 1);
Xa.zeros(N/2 + 1);
XaPrevious.zeros(N/2 + 1);
Xa_arg.zeros(N/2 + 1);
XaPrevious_arg.zeros(N/2 + 1);
d_phi.zeros(N/2 + 1);
d_phi_prime.zeros(N/2 + 1);
d_phi_wrapped.zeros(N/2 + 1);
omega_true_sobre_fs.zeros(N/2 + 1);
AUX.zeros(N/2 + 1);
Xa_abs.zeros(N/2 + 1);
w.zeros(N); hann(N,&w);
I.zeros(N/2 + 1); I = linspace(0, N/2, N/2 + 1);
if (fftwf_import_wisdom_from_filename(wisdomFile) != 0)
{
p = fftwf_plan_dft_r2c_1d(N, frames2, fXa, FFTW_WISDOM_ONLY);
}
else
{
p = NULL;
printf("PSAnalysis: failed to import wisdom file '%s'\n", wisdomFile);
}
}
void init_field(int n_d, int *n, double *L, field_info *FFT) {
ptrdiff_t n_x_local;
ptrdiff_t i_x_start_local;
ptrdiff_t n_y_transpose_local;
ptrdiff_t i_y_start_transpose_local;
ptrdiff_t *n_x_rank;
int flag_active;
int n_active;
int min_size, max_size;
SID_log("Initializing ", SID_LOG_OPEN);
for(ptrdiff_t i_d = 0; i_d < n_d; i_d++) {
if(i_d < (n_d - 1))
SID_log("%dx", SID_LOG_CONTINUE, n[i_d]);
else
SID_log("%d element %d-d FFT ", SID_LOG_CONTINUE, n[i_d], n_d);
}
SID_log("(%d byte precision)...", SID_LOG_CONTINUE, (int)sizeof(GBPREAL));
// Initialize FFT sizes
FFT->n_d = n_d;
FFT->n = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d);
FFT->L = (double *)SID_calloc(sizeof(double) * FFT->n_d);
FFT->n_k_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d);
FFT->n_R_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d);
FFT->i_R_start_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d);
FFT->i_k_start_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d);
FFT->i_R_stop_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d);
FFT->i_k_stop_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d);
for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) {
FFT->n[i_d] = n[i_d];
FFT->L[i_d] = L[i_d];
FFT->i_R_start_local[i_d] = 0;
FFT->i_k_start_local[i_d] = 0;
FFT->n_R_local[i_d] = FFT->n[i_d];
FFT->n_k_local[i_d] = FFT->n[i_d];
}
FFT->n_k_local[FFT->n_d - 1] = FFT->n[FFT->n_d - 1] / 2 + 1;
// Initialize FFTW
// Create an integer version of FFT->n[] to pass to ..._create_plan
int *n_int=(int *)SID_malloc(sizeof(int)*FFT->n_d);
for(int i_d=0;i_d<FFT->n_d;i_d++)
n_int[i_d]=(int)FFT->n[i_d];
#if FFTW_V2
#if USE_MPI
int total_local_size_int;
int n_x_local_int;
int i_x_start_local_int;
int n_y_transpose_local_int;
int i_y_start_transpose_local_int;
FFT->plan = rfftwnd_mpi_create_plan(SID.COMM_WORLD->comm, FFT->n_d, n_int, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE);
FFT->iplan = rfftwnd_mpi_create_plan(SID.COMM_WORLD->comm, FFT->n_d, n_int, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE);
rfftwnd_mpi_local_sizes(FFT->plan,
&(n_x_local_int),
&(i_x_start_local_int),
&(n_y_transpose_local_int),
&(i_y_start_transpose_local_int),
&total_local_size_int);
n_x_local = (ptrdiff_t)n_x_local_int;
i_x_start_local = (ptrdiff_t)i_x_start_local_int;
n_y_transpose_local = (ptrdiff_t)n_y_transpose_local_int;
i_y_start_transpose_local = (ptrdiff_t)i_y_start_transpose_local_int;
FFT->total_local_size = (size_t)total_local_size_int;
#else
FFT->total_local_size = 1;
for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) {
if(i_d < FFT->n_d - 1)
FFT->total_local_size *= FFT->n[i_d];
else
FFT->total_local_size *= 2 * (FFT->n[i_d] / 2 + 1);
}
#if USE_DOUBLE
FFT->plan = fftwnd_create_plan(FFT->n_d, n_int, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE | FFTW_IN_PLACE);
FFT->iplan = fftwnd_create_plan(FFT->n_d, n_int, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE | FFTW_IN_PLACE);
#else
FFT->plan = rfftwnd_create_plan(FFT->n_d, n_int, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE | FFTW_IN_PLACE);
FFT->iplan = rfftwnd_create_plan(FFT->n_d, n_int, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE | FFTW_IN_PLACE);
#endif
#endif
#else
#if USE_MPI
#if USE_DOUBLE
fftw_mpi_init();
FFT->total_local_size = fftw_mpi_local_size_many_transposed(FFT->n_d,
FFT->n,
1,
FFTW_MPI_DEFAULT_BLOCK,
FFTW_MPI_DEFAULT_BLOCK,
SID_COMM_WORLD->comm,
&(n_x_local),
&(i_x_start_local),
&(n_y_transpose_local),
&(i_y_start_transpose_local));
FFT->plan = fftw_mpi_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE);
FFT->iplan = fftw_mpi_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE);
#else
fftwf_mpi_init();
FFT->total_local_size = fftwf_mpi_local_size_many_transposed(FFT->n_d,
FFT->n,
1,
FFTW_MPI_DEFAULT_BLOCK,
FFTW_MPI_DEFAULT_BLOCK,
SID_COMM_WORLD->comm,
&(n_x_local),
&(i_x_start_local),
&(n_y_transpose_local),
&(i_y_start_transpose_local));
FFT->plan = fftwf_mpi_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE);
FFT->iplan = fftwf_mpi_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE);
#endif
#else
FFT->total_local_size = 1;
for(ptrdiff_t i_d=0; i_d < FFT->n_d; i_d++) {
if(i_d < FFT->n_d - 1)
FFT->total_local_size *= FFT->n[i_d];
else
FFT->total_local_size *= 2 * (FFT->n[i_d] / 2 + 1);
}
#if USE_DOUBLE
FFT->plan = fftw_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, FFTW_ESTIMATE);
FFT->iplan = fftw_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, FFTW_ESTIMATE);
#else
FFT->plan = fftwf_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, FFTW_ESTIMATE);
FFT->iplan = fftwf_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, FFTW_ESTIMATE);
#endif
#endif
#endif
SID_free(SID_FARG n_int);
// Set empty slabs to start at 0 to make ignoring them simple.
if(n_x_local == 0)
i_x_start_local = 0;
if(n_y_transpose_local == 0)
i_y_start_transpose_local = 0;
// Modify the local slab dimensions according to what FFTW chose.
FFT->i_R_start_local[0] = i_x_start_local;
FFT->n_R_local[0] = n_x_local;
if(FFT->n_d > 1) {
FFT->i_k_start_local[1] = i_y_start_transpose_local;
FFT->n_k_local[1] = n_y_transpose_local;
}
// Allocate field
#if USE_FFTW3
FFT->field_local = (gbpFFT_real *)fftwf_alloc_real(FFT->total_local_size);
#else
FFT->field_local = (gbpFFT_real *)SID_malloc(sizeof(gbpFFT_real)*FFT->total_local_size);
#endif
FFT->cfield_local = (gbpFFT_complex *)FFT->field_local;
// Upper limits of slab decomposition
for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) {
FFT->i_R_stop_local[i_d] = FFT->i_R_start_local[i_d] + FFT->n_R_local[i_d] - 1;
FFT->i_k_stop_local[i_d] = FFT->i_k_start_local[i_d] + FFT->n_k_local[i_d] - 1;
}
// FFTW padding sizes
if(FFT->n_d > 1) {
FFT->pad_size_R = 2 * (FFT->n_R_local[FFT->n_d - 1] / 2 + 1) - FFT->n_R_local[FFT->n_d - 1];
FFT->pad_size_k = 0;
} else {
FFT->pad_size_R = 0;
FFT->pad_size_k = 0;
}
// Number of elements (global and local) in the FFT
ptrdiff_t i_d = 0;
for(FFT->n_field = 1, FFT->n_field_R_local = 1, FFT->n_field_k_local = 1; i_d < FFT->n_d; i_d++) {
FFT->n_field *= (size_t)FFT->n[i_d];
FFT->n_field_R_local *= (size_t)FFT->n_R_local[i_d];
FFT->n_field_k_local *= (size_t)FFT->n_k_local[i_d];
}
// Clear the field
clear_field(FFT);
// Initialize the FFT's real-space grid
FFT->R_field = (double **)SID_malloc(sizeof(double *) * FFT->n_d);
FFT->dR = (double *)SID_malloc(sizeof(double *) * FFT->n_d);
for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) {
FFT->R_field[i_d] = (double *)SID_malloc(sizeof(double) * (FFT->n[i_d] + 1));
FFT->dR[i_d] = FFT->L[i_d] / (double)(FFT->n[i_d]);
for(ptrdiff_t i_i = 0; i_i < FFT->n[i_d]; i_i++)
FFT->R_field[i_d][i_i] = FFT->L[i_d] * ((double)i_i / (double)(FFT->n[i_d]));
FFT->R_field[i_d][FFT->n[i_d]] = FFT->L[i_d];
}
// Initialize the FFT's k-space grid
FFT->k_field = (double **)SID_malloc(sizeof(double *) * FFT->n_d);
FFT->dk = (double *)SID_malloc(sizeof(double *) * FFT->n_d);
FFT->k_Nyquist = (double *)SID_malloc(sizeof(double *) * FFT->n_d);
for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) {
FFT->k_field[i_d] = (double *)SID_malloc(sizeof(double) * FFT->n[i_d]);
FFT->dk[i_d] = TWO_PI / FFT->L[i_d];
FFT->k_Nyquist[i_d] = TWO_PI * (double)(FFT->n[i_d]) / FFT->L[i_d] / 2.;
for(ptrdiff_t i_i = 0; i_i < FFT->n[i_d]; i_i++) {
if(i_i >= FFT->n[i_d] / 2)
FFT->k_field[i_d][i_i] = TWO_PI * (double)(i_i - FFT->n[i_d]) / FFT->L[i_d];
else
FFT->k_field[i_d][i_i] = TWO_PI * (double)(i_i) / FFT->L[i_d];
}
}
// Flags
FFT->flag_padded = GBP_FALSE;
// Slab info
FFT->slab.n_x_local = FFT->n_R_local[0];
FFT->slab.i_x_start_local = FFT->i_R_start_local[0];
FFT->slab.i_x_stop_local = FFT->i_R_stop_local[0];
FFT->slab.x_min_local = FFT->R_field[0][FFT->i_R_start_local[0]];
if(FFT->slab.n_x_local > 0)
FFT->slab.x_max_local = FFT->R_field[0][FFT->i_R_stop_local[0] + 1];
else
FFT->slab.x_max_local = FFT->slab.x_min_local;
SID_Allreduce(&(FFT->slab.x_max_local), &(FFT->slab.x_max), 1, SID_DOUBLE, SID_MAX, SID_COMM_WORLD);
#if USE_MPI
// All ranks are not necessarily assigned any slices, so
// we need to figure out what ranks are to the right and the left for
// buffer exchanges
n_x_rank = (ptrdiff_t *)SID_malloc(sizeof(ptrdiff_t) * SID.n_proc);
n_x_rank[SID.My_rank] = (ptrdiff_t)FFT->slab.n_x_local;
if(n_x_rank[SID.My_rank] > 0)
flag_active = GBP_TRUE;
else
flag_active = GBP_FALSE;
SID_Allreduce(&flag_active, &n_active, 1, SID_INT, SID_SUM, SID_COMM_WORLD);
SID_Allreduce(&n_x_rank[SID.My_rank], &min_size, 1, SID_INT, SID_MIN, SID_COMM_WORLD);
SID_Allreduce(&n_x_rank[SID.My_rank], &max_size, 1, SID_INT, SID_MAX, SID_COMM_WORLD);
for(int i_rank = 0; i_rank < SID.n_proc; i_rank++)
SID_Bcast(&(n_x_rank[i_rank]), 1, SID_INT, i_rank, SID_COMM_WORLD);
FFT->slab.rank_to_right = -1;
for(int i_rank = SID.My_rank + 1; i_rank < SID.My_rank + SID.n_proc && FFT->slab.rank_to_right < 0; i_rank++) {
int j_rank = i_rank % SID.n_proc;
if(n_x_rank[j_rank] > 0)
FFT->slab.rank_to_right = j_rank;
}
if(FFT->slab.rank_to_right < 0)
FFT->slab.rank_to_right = SID.My_rank;
FFT->slab.rank_to_left = -1;
for(int i_rank = SID.My_rank - 1; i_rank > SID.My_rank - SID.n_proc && FFT->slab.rank_to_left < 0; i_rank--) {
int j_rank = i_rank;
if(i_rank < 0)
j_rank = i_rank + SID.n_proc;
if(n_x_rank[j_rank] > 0)
FFT->slab.rank_to_left = j_rank;
}
if(FFT->slab.rank_to_left < 0)
FFT->slab.rank_to_left = SID.My_rank;
free(n_x_rank);
SID_log("(%d cores unused, min/max slab size=%d/%d)...", SID_LOG_CONTINUE, SID.n_proc - n_active, min_size, max_size);
#else
FFT->slab.rank_to_right = SID.My_rank;
FFT->slab.rank_to_left = SID.My_rank;
if(FFT->slab.n_x_local > 0) {
flag_active = GBP_TRUE;
n_active = 1;
min_size = FFT->slab.n_x_local;
max_size = FFT->slab.n_x_local;
} else {
flag_active = GBP_FALSE;
n_active = 0;
min_size = 0;
max_size = 0;
}
#endif
SID_log("Done.", SID_LOG_CLOSE);
}
float*
malloc_vector_f(size_t n)
{
return fftwf_alloc_real(n);
}
void PitchShifter::run(LV2_Handle instance, uint32_t n_samples)
{
PitchShifter *plugin;
plugin = (PitchShifter *) instance;
float media = 0;
for (uint32_t i=1; i<n_samples; i++)
{
media = media + abs(plugin->in[i-1]);
}
if (media == 0)
{
for (uint32_t i=1; i<n_samples; i++)
{
plugin->out_1[i-1] = 0;
}
}
else
{
int hops;
double g_before = plugin->g;
plugin->g = pow(10, (float)(*(plugin->gain))/20.0);
plugin->s = (double)(*(plugin->step));
hops = round(plugin->hopa*(pow(2,(plugin->s/12))));
for (int k=1; k<= plugin->Qcolumn-1; k++)
{
plugin->Hops[k-1] = plugin->Hops[k];
}
plugin->Hops[plugin->Qcolumn-1] = hops;
if ( ((plugin->hopa) != (int)n_samples) )
{
plugin->hopa = n_samples;
plugin->N = plugin->nBuffers*plugin->hopa;
plugin->frames = (double*)realloc(plugin->frames,plugin->N*sizeof(double)); memset(plugin->frames, 0, plugin->N );
plugin->ysaida = (double*)realloc(plugin->ysaida,2*(plugin->N + 2*(plugin->Qcolumn-1)*plugin->hopa)*sizeof(double)); memset(plugin->ysaida, 0, 2*(plugin->N + 2*(plugin->Qcolumn-1)*plugin->hopa) );
plugin->yshift = (double*)realloc(plugin->yshift,plugin->hopa*sizeof(double)); memset(plugin->yshift, 0, plugin->hopa );
plugin->b = (double**)realloc(plugin->b,plugin->hopa*sizeof(double*));
fftwf_free(plugin->frames2); plugin->frames2 = fftwf_alloc_real(plugin->N);
fftwf_free(plugin->q); plugin->q = fftwf_alloc_real(plugin->N);
fftwf_free(plugin->fXa); plugin->fXa = fftwf_alloc_complex(plugin->N/2 + 1);
fftwf_free(plugin->fXs); plugin->fXs = fftwf_alloc_complex(plugin->N/2 + 1);
plugin->Xa.zeros(plugin->N/2 + 1);
plugin->Xs.zeros(plugin->N/2 + 1);
plugin->XaPrevious.zeros(plugin->N/2 + 1);
plugin->Xa_arg.zeros(plugin->N/2 + 1);
plugin->XaPrevious_arg.zeros(plugin->N/2 + 1);
plugin->Phi.zeros(plugin->N/2 + 1);
plugin->PhiPrevious.zeros(plugin->N/2 + 1);
plugin->d_phi.zeros(plugin->N/2 + 1);
plugin->d_phi_prime.zeros(plugin->N/2 + 1);
plugin->d_phi_wrapped.zeros(plugin->N/2 + 1);
plugin->omega_true_sobre_fs.zeros(plugin->N/2 + 1);
plugin->AUX.zeros(plugin->N/2 + 1);
plugin->Xa_abs.zeros(plugin->N/2 + 1);
plugin->w.zeros(plugin->N); hann(plugin->N,&plugin->w);
plugin->I.zeros(plugin->N/2 + 1); plugin->I = linspace(0, plugin->N/2,plugin->N/2 + 1);
for (int i=1 ; i<= plugin->nBuffers; i++)
{
plugin->b[i-1] = &plugin->frames[(i-1)*plugin->hopa];
}
fftwf_destroy_plan(plugin->p); plugin->p = fftwf_plan_dft_r2c_1d(plugin->N, plugin->frames2, plugin->fXa, FFTW_ESTIMATE);
fftwf_destroy_plan(plugin->p2); plugin->p2 = fftwf_plan_dft_c2r_1d(plugin->N, plugin->fXs, plugin->q, FFTW_ESTIMATE);
return;
}
for (int i=1; i<=plugin->hopa; i++)
{
for (int j=1; j<=(plugin->nBuffers-1); j++)
{
plugin->b[j-1][i-1] = plugin->b[j][i-1];
}
plugin->b[plugin->nBuffers-1][i-1] = plugin->in[i-1];
}
if ( plugin->cont < plugin->nBuffers-1)
{
plugin->cont = plugin->cont + 1;
}
else
{
shift(plugin->N, plugin->hopa, plugin->Hops, plugin->frames, plugin->frames2, &plugin->w, &plugin->XaPrevious, &plugin->Xa_arg, &plugin->Xa_abs, &plugin->XaPrevious_arg, &plugin->PhiPrevious, plugin->yshift, &plugin->Xa, &plugin->Xs, plugin->q, &plugin->Phi, plugin->ysaida, plugin->ysaida2, plugin->Qcolumn, &plugin->d_phi, &plugin->d_phi_prime, &plugin->d_phi_wrapped, &plugin->omega_true_sobre_fs, &plugin->I, &plugin->AUX, plugin->p, plugin->p2, plugin->fXa, plugin->fXs);
for (int i=1; i<=plugin->hopa; i++)
{
plugin->out_1[i-1] = (g_before + ((plugin->g - g_before)/(plugin->hopa - 1))*(i-1) )*(float)plugin->yshift[i-1];
}
}
}
}
