FormantFilter::~FormantFilter() { for (int i = 0; i < numformants; ++i) delete(formant[i]); fftwf_free(inbuffer); fftwf_free(tmpbuf); }
void dft_plan_free(dft_plan_t *plan) { if (!plan) return; if (!plan->size) return; if (plan->in) fftwf_free(plan->in); if (plan->out) fftwf_free(plan->out); if (plan->p) fftwf_destroy_plan(plan->p); }
temporaryMemFFT::~temporaryMemFFT() { if(allocated_!=0){ #pragma acc exit data delete(temp1_) #pragma acc exit data delete(temp2_) #ifndef FFT3D_ACC #ifdef SINGLE fftwf_free(temp1_); fftwf_free(temp2_); #endif #ifndef SINGLE fftw_free(temp1_); fftw_free(temp2_); #endif #else free(temp1_); free(temp2_); #endif } if(allocatedReal_!=0){ #pragma acc exit data delete(tempReal_) free(tempReal_); } #pragma acc exit data delete(this) }
void AFComplexVector<fftwf_complex, float>::SetLength(const AFSampleCount smpcLength) { assert(smpcLength > 0.0); if(m_smpcLength == 0) { m_smpcLength = smpcLength; if(m_pcpxUf) fftwf_free(m_pcpxUf); m_pcpxUf = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * m_smpcLength); } else { // create a temporary vector for storing purposes fftwf_complex* pcpxTmp = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * m_smpcLength); memcpy(pcpxTmp, m_pcpxUf, sizeof(fftwf_complex) * m_smpcLength); fftwf_free(m_pcpxUf); // enlarge the vector m_pcpxUf = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * smpcLength); memset(m_pcpxUf, 0, sizeof(fftwf_complex) * smpcLength); // copy backup to new vector memcpy(m_pcpxUf, pcpxTmp, sizeof(fftwf_complex) * m_smpcLength); fftwf_free(pcpxTmp); // set new length attribute m_smpcLength = smpcLength; } }
ProcessSamples::~ProcessSamples() { for (uint32_t threadId = 0; threadId < this->m_threadCount; threadId++) { fftwf_free(this->m_inputSamples[threadId]); fftwf_free(this->m_fftOutputBuffer[threadId]); } }
DCTFFTW::~DCTFFTW() { fftwf_destroy_plan(dctplan); fftwf_free(fSrc); fftwf_free(fSrcDCT); }
Transform::~Transform() { free(outputmag); fftwf_free(_the_input); fftwf_free(_the_output); fftwf_destroy_plan(_the_plan); }
static void fftw_fini(struct fftw_state *state) { fftwf_destroy_plan(state->p); fftwf_free(state->out); fftwf_free(state->in); }
OfdmGenerator::~OfdmGenerator() { PDEBUG("OfdmGenerator::~OfdmGenerator() @ %p\n", this); #if USE_FFTW if (myFftIn) { fftwf_free(myFftIn); } if (myFftOut) { fftwf_free(myFftOut); } if (myFftPlan) { fftwf_destroy_plan(myFftPlan); } #else if (myFftPlan != NULL) { kiss_fft_free(myFftPlan); } if (myFftBuffer != NULL) { free(myFftBuffer); } kiss_fft_cleanup(); #endif }
void wavelet_prepare(PluginData *pd) { int w = pd->image_width, h = pd->image_height, pw = w/2+1; // physical width fftwf_complex *multiplied = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * pw * h); float *image_temp = (float*)fftwf_malloc(sizeof(float) * w * h); float diagonal = sqrt(h*h + w*w)/2; pd->image_wavelet = (char*)fftwf_malloc(WAVELET_DEPTH * w * h * sizeof(char)); // printf("Wavelet layers occupy %lu MB.\n", (WAVELET_DEPTH * w * h * sizeof(short)) >> 20); // TODO: keep only the selected part of the image (->save memory) int lower = 0, peak = 1, upper = scale_to_dist(1, diagonal); for (int scale = 0; scale < WAVELET_DEPTH; scale ++) { float above = upper-peak, below = peak-lower; for (int i=0; i < pw*h; i++){ multiplied[i][0] = multiplied[i][1] = 0.0; } for (int i=0; i < pw*h; i++) { float dist = index_to_dist(i, pw, h); if (dist <= upper){ if (dist > lower){ if (dist > peak){ for(int channel=0; channel < pd->channel_count; channel ++) { multiplied[i][0] += pd->image_freq[channel][i][0]; multiplied[i][1] += pd->image_freq[channel][i][1]; } float coef = (1.0 - (dist-peak)/above) / pd->channel_count; multiplied[i][0] *= coef; multiplied[i][1] *= coef; } else { for(int channel=0; channel < pd->channel_count; channel ++) { multiplied[i][0] += pd->image_freq[channel][i][0]; multiplied[i][1] += pd->image_freq[channel][i][1]; } float coef = (1.0 - (peak-dist)/below) / pd->channel_count; multiplied[i][0] *= coef; multiplied[i][1] *= coef; } } } } // apply inverse FFT fftwf_execute_dft_c2r(pd->plan, multiplied, image_temp); for (int i=0; i < w*h; i++) { pd->image_wavelet[i*WAVELET_DEPTH + scale] = CLAMPED(image_temp[i], -127, 127); } lower = peak; peak = upper; upper = scale_to_dist(scale+2, diagonal); } fftwf_free(multiplied); fftwf_free(image_temp); }
void srslte_dft_plan_free(srslte_dft_plan_t *plan) { if (!plan) return; if (!plan->size) return; if (plan->in) fftwf_free(plan->in); if (plan->out) fftwf_free(plan->out); if (plan->p) fftwf_destroy_plan(plan->p); bzero(plan, sizeof(srslte_dft_plan_t)); }
MyMFCC::~MyMFCC() { delete[] m_melOffsets; delete[] m_melCoeff; fftwf_free(m_dctIn); fftwf_free(m_dctOut); fftwf_destroy_plan(m_plan); }
void grav_fft_init() { int xblock2 = XRES/CELL*2; int yblock2 = YRES/CELL*2; int x, y, fft_tsize = (xblock2/2+1)*yblock2; float distance, scaleFactor; fftwf_plan plan_ptgravx, plan_ptgravy; if (grav_fft_status) return; //use fftw malloc function to ensure arrays are aligned, to get better performance th_ptgravx = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_ptgravy = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_ptgravxt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_ptgravyt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_gravmapbig = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_gravmapbigt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_gravxbig = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_gravybig = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_gravxbigt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_gravybigt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); //select best algorithm, could use FFTW_PATIENT or FFTW_EXHAUSTIVE but that increases the time taken to plan, and I don't see much increase in execution speed plan_ptgravx = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravx, th_ptgravxt, FFTW_MEASURE); plan_ptgravy = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravy, th_ptgravyt, FFTW_MEASURE); plan_gravmap = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_gravmapbig, th_gravmapbigt, FFTW_MEASURE); plan_gravx_inverse = fftwf_plan_dft_c2r_2d(yblock2, xblock2, th_gravxbigt, th_gravxbig, FFTW_MEASURE); plan_gravy_inverse = fftwf_plan_dft_c2r_2d(yblock2, xblock2, th_gravybigt, th_gravybig, FFTW_MEASURE); //(XRES/CELL)*(YRES/CELL)*4 is size of data array, scaling needed because FFTW calculates an unnormalized DFT scaleFactor = -M_GRAV/((XRES/CELL)*(YRES/CELL)*4); //calculate velocity map caused by a point mass for (y=0; y<yblock2; y++) { for (x=0; x<xblock2; x++) { if (x==XRES/CELL && y==YRES/CELL) continue; distance = sqrtf(pow(x-(XRES/CELL), 2) + pow(y-(YRES/CELL), 2)); th_ptgravx[y*xblock2+x] = scaleFactor*(x-(XRES/CELL)) / pow(distance, 3); th_ptgravy[y*xblock2+x] = scaleFactor*(y-(YRES/CELL)) / pow(distance, 3); } } th_ptgravx[yblock2*xblock2/2+xblock2/2] = 0.0f; th_ptgravy[yblock2*xblock2/2+xblock2/2] = 0.0f; //transform point mass velocity maps fftwf_execute(plan_ptgravx); fftwf_execute(plan_ptgravy); fftwf_destroy_plan(plan_ptgravx); fftwf_destroy_plan(plan_ptgravy); fftwf_free(th_ptgravx); fftwf_free(th_ptgravy); //clear padded gravmap memset(th_gravmapbig,0,xblock2*yblock2*sizeof(float)); grav_fft_status = 1; }
PitchTracker::~PitchTracker() { stop_thread(); fftwf_destroy_plan(m_fftwPlanFFT); fftwf_destroy_plan(m_fftwPlanIFFT); fftwf_free(m_fftwBufferTime); fftwf_free(m_fftwBufferFreq); delete[] m_input; delete[] m_buffer; }
InputSource::~InputSource() { fftwf_destroy_plan(m_fftw_plan); fftwf_free(m_fftw_in); fftwf_free(m_fftw_out); free(m_output_cache); munmap(m_data, m_file_size); fclose(m_file); }
void PPFChanneliser::_createFFTWPlan(unsigned nChannels, fftwf_plan& plan) { size_t fftSize = nChannels * sizeof(fftwf_complex); fftwf_complex* in = (fftwf_complex*) fftwf_malloc(fftSize); fftwf_complex* out = (fftwf_complex*) fftwf_malloc(fftSize); plan = fftwf_plan_dft_1d(_nChannels, in, out, FFTW_FORWARD, FFTW_MEASURE); fftwf_free(in); fftwf_free(out); }
void hcCloseTripple(HConvTripple *filter) { hcCloseSingle(filter->f_short); free(filter->f_short); hcCloseDual(filter->f_medium); free(filter->f_medium); fftwf_free(filter->out_medium); fftwf_free(filter->in_medium); memset(filter, 0, sizeof(HConvTripple)); }
void hcCloseDual(HConvDual *filter) { hcCloseSingle(filter->f_short); free(filter->f_short); hcCloseSingle(filter->f_long); free(filter->f_long); fftwf_free(filter->out_long); fftwf_free(filter->in_long); memset(filter, 0, sizeof(HConvDual)); }
void FFTWEngine::freeAll() { for(Plans::iterator it = m_plans.begin(); it != m_plans.end(); ++it) { fftwf_destroy_plan((*it)->plan); fftwf_free((*it)->in); fftwf_free((*it)->out); delete *it; } m_plans.clear(); }
void fft_destroy(PluginData *pd) { fftwf_destroy_plan(pd->plan); for (int i=0; i<pd->channel_count; i++){ fftwf_free(pd->image[i]); fftwf_free(pd->image_freq[i]); } free(pd->image); free(pd->image_freq); }
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; }
void SingleParticle2dx::Utilities::FFTCalculator::performBackwardFFT (fft_array2d_type* fourier_data, real_array2d_type* real_data) { size_type nx = fourier_data->shape()[0]; size_type ny = fourier_data->shape()[1]; size_type n_part = SingleParticle2dx::ConfigContainer::Instance()->getParticleSize(); SingleParticle2dx::Utilities::FFTPlanContainer* plan_cont = SingleParticle2dx::Utilities::FFTPlanContainer::Instance(); fftwf_complex* in = (fftwf_complex *) fftwf_malloc ( sizeof(fftwf_complex)*nx*ny); fftwf_complex* out = (fftwf_complex *) fftwf_malloc ( sizeof(fftwf_complex)*nx*ny); fftwf_complex* out_pointer = out; for (size_type i=0; i<nx; i++) { for (size_type j=0; j<ny; j++) { out_pointer[j+i*ny][0] = (*fourier_data)[i][j].real(); out_pointer[j+i*ny][1] = (*fourier_data)[i][j].imag(); } } fftwf_plan p2_bw; real_array2d_type* pow_array; if( nx == 4*n_part ) { p2_bw = plan_cont->getBW_4_2d(); pow_array = plan_cont->getLargePowArray2D(); } else { p2_bw = plan_cont->getBW_2d(); pow_array = plan_cont->getSmallPowArray2D(); } // fftw3_mkl.verbose = 10; fftwf_execute_dft(p2_bw, out, in); fftwf_complex* in_pointer = in; value_type power; for (size_type i=0; i<nx; i++) { for (size_type j=0; j<ny; j++) { power = (*pow_array)[i][j]; //((*real_data)[i][j]) = in.get()[j+i*ny][0] * powf(-1.0,i+j) / n; ((*real_data)[i][j]) = in_pointer[j+i*ny][0] * power; } } fftwf_free(in); fftwf_free(out); }
int temporaryMemFFT::setTemp(long size) { if(size>allocated_) { if(allocated_!=0){ #pragma acc exit data delete(temp1_) #pragma acc exit data delete(temp2_) #ifndef FFT3D_ACC #ifdef SINGLE fftwf_free(temp1_); fftwf_free(temp2_); #endif #ifndef SINGLE fftw_free(temp1_); fftw_free(temp2_); #endif #else free(temp1_); free(temp2_); #endif } long alocSize; alocSize = 2*size; #ifndef FFT3D_ACC #ifdef SINGLE temp1_ = (fftwf_complex *)fftwf_malloc(alocSize*sizeof(fftwf_complex)); temp2_ = (fftwf_complex *)fftwf_malloc(alocSize*sizeof(fftwf_complex)); #endif #ifndef SINGLE temp1_ = (fftw_complex *)fftw_malloc(alocSize*sizeof(fftw_complex)); temp2_ = (fftw_complex *)fftw_malloc(alocSize*sizeof(fftw_complex)); #endif #else #ifdef SINGLE temp1_ = (fftwf_complex *)malloc(alocSize*sizeof(fftwf_complex)); temp2_ = (fftwf_complex *)malloc(alocSize*sizeof(fftwf_complex)); #endif #ifndef SINGLE temp1_ = (fftw_complex *)malloc(alocSize*sizeof(fftw_complex)); temp2_ = (fftw_complex *)malloc(alocSize*sizeof(fftw_complex)); #endif #endif /// maybe add temp2_ if segfault #pragma acc enter data create(temp1_[0:alocSize][0:2]) #pragma acc enter data create(temp2_[0:alocSize][0:2]) } return 1; }
void lpt_finalize(void) { for(int i=0; i<3; i++) { fftwf_free(cdisp[i]); fftwf_free(cdisp2[i]); } for(int i=0; i<6; i++) fftwf_free(cdigrad[i]); fftwf_mpi_cleanup(); }
static void deinit(void) { fftwf_destroy_plan(p); fftwf_free(in); fftwf_free(out); free(outL); free(outR); free(buffer); free(lamp); free(curlHue); free(hueLampMap); }
PSSinthesis::~PSSinthesis() //Destrutor { delete[] hops; delete[] ysaida; delete[] yshift; fftwf_free(q); fftwf_free(fXs); Xs.clear(); Phi.clear(); PhiPrevious.clear(); if (p2) fftwf_destroy_plan(p2); }
void padsynth_free_temp(void) { if (global.padsynth_outfreqs) { fftwf_free(global.padsynth_outfreqs); global.padsynth_outfreqs = NULL; } if (global.padsynth_outsamples) { fftwf_free(global.padsynth_outsamples); global.padsynth_outsamples = NULL; } }
OptFFT::~OptFFT() { fftwf_destroy_plan(m_p); fftwf_free(m_pIn); fftwf_free(m_pOut); for (int i = 0; i < m_maxFrames; ++i) delete [] m_pFrames[i]; delete [] m_pFrames; }
ofxFftw::~ofxFftw() { if (fftPlan != NULL) { fftwf_destroy_plan(fftPlan); fftwf_free(fftIn); fftwf_free(fftOut); fftwf_destroy_plan(ifftPlan); fftwf_free(ifftIn); fftwf_free(ifftOut); fftwf_cleanup(); } }
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; }