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;
}
