DCTFFTW::~DCTFFTW()
{
fftwf_destroy_plan(dctplan);
fftwf_free(fSrc);
fftwf_free(fSrcDCT);
}
int srslte_dft_replan_guru_c(srslte_dft_plan_t *plan, const int new_dft_points, cf_t *in_buffer,
cf_t *out_buffer, int istride, int ostride, int how_many,
int idist, int odist) {
int sign = (plan->forward) ? FFTW_FORWARD : FFTW_BACKWARD;
const fftwf_iodim iodim = {new_dft_points, istride, ostride};
const fftwf_iodim howmany_dims = {how_many, idist, odist};
pthread_mutex_lock(&fft_mutex);
/* Destroy current plan */
fftwf_destroy_plan(plan->p);
plan->p = fftwf_plan_guru_dft(1, &iodim, 1, &howmany_dims, in_buffer, out_buffer, sign, FFTW_TYPE);
pthread_mutex_unlock(&fft_mutex);
if (!plan->p) {
return -1;
}
plan->size = new_dft_points;
plan->init_size = plan->size;
return 0;
}
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
}
static void
fftw_fini(struct fftw_state *state)
{
fftwf_destroy_plan(state->p);
fftwf_free(state->out);
fftwf_free(state->in);
}
void SpectrumVisualProcessor::setup(int fftSize_in) {
busy_run.lock();
fftSize = fftSize_in;
desiredInputSize.store(fftSize);
if (fftwInput) {
free(fftwInput);
}
fftwInput = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * fftSize);
if (fftInData) {
free(fftInData);
}
fftInData = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * fftSize);
if (fftLastData) {
free(fftLastData);
}
fftLastData = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * fftSize);
if (fftwOutput) {
free(fftwOutput);
}
fftwOutput = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * fftSize);
if (fftw_plan) {
fftwf_destroy_plan(fftw_plan);
}
fftw_plan = fftwf_plan_dft_1d(fftSize, fftwInput, fftwOutput, FFTW_FORWARD, FFTW_ESTIMATE);
busy_run.unlock();
}
/**
* Clean up all allocations etc
* @return int Returns 0 on success
*/
int TaskCoreFFTW::finalize()
{
terminate_worker = true;
this->processing_stage = STAGE_NONE;
while (processing_stage != STAGE_EXIT) {
pthread_mutex_unlock(&mmutex);
pthread_yield();
pthread_mutex_lock(&mmutex);
}
pthread_mutex_unlock(&mmutex);
pthread_join(wthread, NULL);
pthread_mutex_destroy(&mmutex);
cerr << "FFTW core " << rank << " completed: " << total_runtime << "s total internal calculation time, " << total_ffts << " FFTs" << endl << flush;
free(windowfct);
free(unpacked_re);
for (int s=0; s<cfg->num_sources; s++) {
fftwf_destroy_plan(fftwPlans[s]);
free(fft_result_reim[s]);
free(fft_accu_reim[s]);
}
delete fftwPlans;
delete fft_accu_reim;
delete fft_result_reim;
free(fft_result_reim_conj);
free(spectrum_scalevector);
return 0;
}
// Create FFT kernels for template matching
void createFFTKernel(fftwf_complex *kernel, unsigned factor, unsigned fftlen)
{
unsigned i;
float values[fftlen];
memset(values, 0, fftlen * sizeof(fftlen));
for (i = 0; i < factor / 2 + 1 ; i++)
values[i] += 1;
if (factor % 2) // Downfactor is odd
for (i = fftlen - factor / 2; i < fftlen; i++)
values[i] += 1;
else if (factor > 2) // Downfactor is even
for (i = fftlen - (factor / 2 - 1); i < fftlen; i++)
values[i] += 1;
for (i = 0; i < fftlen; i++)
values[i] /= sqrt(factor);
// Create FFT plan and execute
fftwf_plan plan = fftwf_plan_dft_r2c_1d(fftlen, values, kernel, FFTW_ESTIMATE);
fftwf_execute(plan);
fftwf_destroy_plan(plan);
}
void Fft<TimeType>::createPlan()
{
if (plan_) {
boost::mutex::scoped_lock lock(getFftwfCoordinator()->getPlanMutex());
fftwf_destroy_plan(*plan_);
}
//reserve data in case we are too small in time and frequency
size_t timeSize=vTime_.size();
if (timeSize < length_)
{
vTime_.reserve(length_);
}
size_t numFreqPts = this->getFreqPoints();
if (vFreq_.size()<numFreqPts)
vFreq_.reserve(numFreqPts);
// TODO is lock required here? I don't think so. fftwf_plan is a fftwf_plan_s struct.
// Cannot tell if it's constructor or creation is thread-safe. Try without first.
plan_ =new fftwf_plan;
//save off these time pointers at plan creation time to be on the safe side
timePtr_ = &vTime_[0];
freqPtr_ = &vFreq_[0];
//run the sub class method to create the plan depending upon what type of fft we are
planCmd();
}
void grav_fft_cleanup()
{
if (!grav_fft_status) return;
fftwf_free(th_ptgravxt);
fftwf_free(th_ptgravyt);
fftwf_free(th_gravmapbig);
fftwf_free(th_gravmapbigt);
fftwf_free(th_gravxbig);
fftwf_free(th_gravybig);
fftwf_free(th_gravxbigt);
fftwf_free(th_gravybigt);
fftwf_destroy_plan(plan_gravmap);
fftwf_destroy_plan(plan_gravx_inverse);
fftwf_destroy_plan(plan_gravy_inverse);
grav_fft_status = 0;
}
int main(int argc, char *argv[])
{
assert(argc == 4 && "fft_host <M> <N> <OutputFilenamePrefix>");
char *dummy;
const int M = strtol(argv[1], &dummy, 10);
const int N = strtol(argv[2], &dummy, 10);
fftwf_complex *in = malloc(M*N*sizeof(*in));
fftwf_complex *out = malloc(M*N*sizeof(*in));
assert(in && out && "Failed to allocate input and output arrays");
srand(time(NULL)); //Seed RNG
for(int i = 0; i < (M*N); i++) {
in[i][0] = (float)((float)rand()+rand()+rand()+rand()) / (float)(4.0f*RAND_MAX) * (float)RANGE;
in[i][1] = (float)((float)rand()+rand()+rand()+rand()) / (float)(4.0f*RAND_MAX) * (float)RANGE;
}
fftwf_plan p = fftwf_plan_dft_2d(M, N, in, out, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT);
fftwf_execute(p);
char inFilename[128], outFilename[128];
strncpy(inFilename, argv[3], 128);
strncpy(outFilename, argv[3], 128);
output(in, M, N, strncat(inFilename, ".t.in", 5), false);
output(out, M, N, strncat(outFilename, ".t.out", 6), false);
strncpy(inFilename, argv[3], 128);
strncpy(outFilename, argv[3], 128);
output(in, M, N, strncat(inFilename, ".b.in", 5), true);
output(out, M, N, strncat(outFilename, ".b.out", 6), true);
fftwf_destroy_plan(p);
free(out);
free(in);
return 0;
}
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);
}
//----------------------------------------------------------------------------
AudioInput::~AudioInput()
{
if (buffer)
delete[] buffer;
if (magnitude != NULL)
delete[] magnitude;
if (audiobars != NULL)
delete[] audiobars;
if (temp_bars != NULL)
{
delete[] temp_bars;
/*for (int i=0; i<nof_bands; i++)
{
delete bp_filter[i];
}*/
//free(bp_filter);
delete[] bp_filter;
}
fftwf_destroy_plan(plan);
fftwf_free(fftout);
delete[] fftin;
delete[] fftMag;
delete[] fftBands;
delete[] fftBandsTemp;
}
Transform::~Transform() {
free(outputmag);
fftwf_free(_the_input);
fftwf_free(_the_output);
fftwf_destroy_plan(_the_plan);
}
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));
}
Fft<TimeType>::~Fft(void)
{
if (plan_) {
boost::mutex::scoped_lock lock(getFftwfCoordinator()->getPlanMutex());
fftwf_destroy_plan(*plan_);
}
plan_=NULL;
}
MyMFCC::~MyMFCC()
{
delete[] m_melOffsets;
delete[] m_melCoeff;
fftwf_free(m_dctIn);
fftwf_free(m_dctOut);
fftwf_destroy_plan(m_plan);
}
void Perform_FFT(float2 *spectra, int nChannels){
int N=nChannels;
fftwf_plan p;
p = fftwf_plan_dft_1d(N, (fftwf_complex *) spectra, (fftwf_complex *) spectra, FFTW_FORWARD, FFTW_ESTIMATE);
fftwf_execute(p);
fftwf_destroy_plan(p);
}
equalizer::~equalizer() {
delete[] bands_;
bands_=0;
delete[] freqs_;
freqs_=0;
size_=0;
// delete FFT plans
fftwf_destroy_plan(fft_);
fftwf_destroy_plan(ifft_);
fftwf_free(hn_);
fftwf_free(Hw_);
delete[] wnd_;
}
void compute() {
const int M = 256;
const int N = 256;
cmatrix h_naught(M, N, true, complex(0.0f, 0.0f));
for (int row = 0; row < M; row++) {
for (int col = 0; col < N; col++) {
int n = col;
int m = row;
matrix3x1 K = Pi_2 * matrix3x1((float)n / N, 0, (float)m / M);
complex h_0 = height_naught(K);
h_naught.set(row, col, h_0);
}
}
cmatrix h_tilde(M, N, true, complex(0, 0));
cmatrix c_heights(M, N, true, complex(0, 0));
fftwf_plan plan = fftwf_plan_dft_2d(M, N, (fftwf_complex *)h_tilde.getData(),
(fftwf_complex *)c_heights.getData(), FFTW_BACKWARD, FFTW_ESTIMATE);
matrix heights(M, N, true, 0.0f);
const int Frames = 1;
for (int p = 0; p < Frames; p++) {
float t = (float)p / Frames;
for (int row = 0; row < M; row++) {
for (int col = 0; col < N; col++) {
h_tilde.set(row, col, Htilde(h_naught, row, col, t));
}
}
// complex2complex FFT2D
fftwf_execute(plan);
// extract the real component
for (int row = 0; row < M; row++) {
for (int col = 0; col < N; col++) {
heights.set(row, col, c_heights.get(row, col).r / 20.0f);
}
}
// save the results
{
std::stringstream ss;
ss << "ocean_" << std::setw(2) << std::setfill('0') << p << ".mat";
std::ofstream file(ss.str().c_str());
file << std::setprecision(10);
math::matrix_writeAsText(file, heights);
}
}
fftwf_destroy_plan(plan);
}
// free
void firbank_free(t_firbank *x) {
int i;
dsp_free(&(x->x_obj));
if(x->input != NULL) {
free(x->input);
}
if(x->output != NULL) {
free(x->output);
}
if(x->framesize) {
fftwf_free(x->x_forward_t);
fftwf_free(x->x_forward_c);
fftwf_free(x->x_inverse_t);
fftwf_free(x->x_inverse_c);
fftwf_destroy_plan(x->x_forward);
fftwf_destroy_plan(x->x_inverse);
fftwf_free(x->input_copy);
}
if(x->filter_states != NULL) {
for(i = 0; i < x->m; i++) {
fftwf_free(x->filter_states[i].tail);
}
free(x->filter_states);
}
if(x->filters != NULL) {
free(x->filters);
}
if(x->w != NULL) {
free(x->w);
}
// post("firbank~: object destroyed.");
}
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 scfft_destroy(scfft *f, SCFFT_Allocator & alloc)
{
if (f == NULL)
return;
#if SC_FFT_FFTW
fftwf_destroy_plan(f->plan);
#endif
alloc.free(f);
}
void rfft(float* buffer,
float* result,
int size)
{
fftwf_plan plan;
plan = fftwf_plan_dft_r2c_1d(size, buffer, (fftwf_complex*) result,FFTW_ESTIMATE);
fftwf_execute(plan);
fftwf_destroy_plan(plan);
}
void PartitionedIR_freqDomain::setNewIRF(const IRF* irf, unsigned int blockSize) {
//Delete if created before
if(real_.data_) {
delete [] real_;
delete [] imaginary_;
}
//.
//Setting
numOfChannels_ = irf->numOfChannels_;
partSize_ = 2 * blockSize;
numOfPartsPerChannel_ = ceil((float_type)irf->N_ / (float_type)blockSize);
channelLength_ = numOfPartsPerChannel_ * partSize_;
unsigned int dataLength = numOfChannels_ * channelLength_;
real_ = new float_type [dataLength];
imaginary_ = new float_type [dataLength];
//.
//FFT Plan
fftwf_iodim dim = {(int) (partSize_),1,1};
fftwf_iodim dim2= {(int) (numOfPartsPerChannel_ * numOfChannels_), (int) (partSize_), (int) (partSize_) };
//---
fftwf_plan fftPlan = fftwf_plan_guru_split_dft(1, &dim, 1, &dim2, real_.data_, imaginary_.data_, real_.data_, imaginary_.data_, FFTW_ESTIMATE);
//.
//Init Real and Imaginary part (each filter part has half samples from ir and half 0)
//Real
for(unsigned int channNum = 0; channNum < numOfChannels_; ++channNum) {
unsigned int partNum;
//parts 0,1... numOfPartsPerChannel_-2
for(partNum = 0; partNum < numOfPartsPerChannel_ - 1; ++partNum) {
memcpy (real_[channNum] + partNum*/*PART_SIZE*/partSize_, irf->h_[channNum] + partNum*/*BLOCK_SIZE*/blockSize, sizeof(float_type) * blockSize );
std::fill_n (real_[channNum] + partNum*partSize_ + blockSize, blockSize, 0);
}
//.
//part numOfPartsPerChannel_-1 (last)
unsigned int numOfSamplesFromIrInLastPart = (irf->N_%blockSize);
memcpy (real_[channNum] + partNum*partSize_, irf->h_[channNum] + partNum*blockSize, sizeof(float_type) * numOfSamplesFromIrInLastPart );
std::fill_n (real_[channNum] + partNum*partSize_ + numOfSamplesFromIrInLastPart, partSize_ - numOfSamplesFromIrInLastPart, 0);
//.
}
//.
//Imaginary
for(unsigned int sampleNum = 0; sampleNum < dataLength; ++sampleNum)
imaginary_.data_[sampleNum] = 0;
//.
//.
fftwf_execute(fftPlan);
fftwf_destroy_plan(fftPlan);
}
void destroy_siphon (SIPHON a)
{
DeleteCriticalSection(&a->update);
fftwf_destroy_plan (a->sipplan);
_aligned_free (a->window);
_aligned_free (a->specout);
_aligned_free (a->sipout);
_aligned_free (a->sipbuff);
_aligned_free (a);
}
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);
}
PitchDetection::~PitchDetection() //Destructor
{
delete[] b;
fftwf_free(frames);
fftwf_free(q);
fftwf_free(fXa);
fftwf_free(fXs);
Xa.clear();
Xs.clear();
R.clear();
NORM.clear();
F.clear();
AUTO.clear();
if (p) fftwf_destroy_plan(p);
if (p2) fftwf_destroy_plan(p2);
}
void ifft(float* buffer,
float* result,
int size)
{
fftwf_plan plan;
plan = fftwf_plan_dft_c2r_1d(size, (fftwf_complex*) buffer,
result,FFTW_ESTIMATE|FFTW_PRESERVE_INPUT);
fftwf_execute(plan);
fftwf_destroy_plan(plan);
}
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();
}
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;
}
