void
reassignment_frequency_correction(sample_t *samples, index_t n_samples, index_t frame_length, index_t fft_length, double sampling_rate, double correct_frequency) {
double binwidth = sampling_rate*(1.0/(fft_length/2.0))*(1/2.0);
frame_length = min_i(frame_length, min_i(fft_length, n_samples));
int n_bins = (fft_length+1)/2;
double window[fft_length];
double frequency_window[fft_length];
double window_correction = 0,frequency_window_correction = 0;
for (int k = 0; k < fft_length; k++) {
window[k] = 0.5*(1-cos(2*M_PI*(k+0.5)/fft_length));
window_correction += window[k]*window[k];
dp(31, "window[%d]=%g\n", k, window[k]);
}
for (int k = 1; k < fft_length-1; k++)
frequency_window[k] = 0.5*(window[k+1]-window[k-1]);
frequency_window[0] = 0.5*window[1];
frequency_window[fft_length-1] = -0.5*window[fft_length-2];
for (int k = 0; k < fft_length; k++)
frequency_window_correction += frequency_window[k]*frequency_window[k];
double frequency_window1[fft_length];
for (int k = 0; k < fft_length; k++)
frequency_window1[k] = sin(2*M_PI*(k+0.5)/fft_length);
// gnuplotf("width=1200 height=1000 rows=2 title='hann' length=%d %lf;title='frequency' %lf title='frequency1' %lf", fft_length, window, frequency_window,frequency_window1);exit(0);
double in[fft_length+2];
for (int k = 0; k < fft_length; k++)
in[k] = window[k]*samples[k];
fftw_complex out[fft_length+2];
fftw_execute(fftw_plan_dft_r2c_1d(fft_length, in, out, FFTW_ESTIMATE));
for (int k = 0; k < fft_length; k++)
in[k] = frequency_window[k]*samples[k];
fftw_complex frequency_out[fft_length+2];
fftw_execute(fftw_plan_dft_r2c_1d(fft_length, in, frequency_out, FFTW_ESTIMATE));
// gnuplotf("width=1200 height=1000 rows=2 title='hann' length=%d %lf;title='frequency' %lf", fft_length, out, frequency_out);
double power[n_bins] ;
for (int k = 0; k < n_bins; k++) {
double real = out[k][0];
double imaginary = out[k][1];
power[k] = (real*real + imaginary*imaginary);
}
for (int bin = 1; bin < n_bins-1; bin++) {
if (power[bin] < 0.0001)
continue;
if ((bin > 0 && power[bin-1] >= power[bin]) || (bin < n_bins - 1 && power[bin+1] >= power[bin]))
continue;
//calculate complex conjugate for complex division
double deviation = -(frequency_out[bin][1] *out[bin][0] - frequency_out[bin][0] * out[bin][1]);
deviation *= 2*sqrt(frequency_window_correction)/sqrt(window_correction);
printf("reassignment bin=%d amplitude=%g frequency=%g deviation=%g\n", bin, sqrt(power[bin]), ((double)bin + deviation) * binwidth, deviation);
printf("error=%g\n", deviation*binwidth/(correct_frequency-bin*binwidth));
}
}
VideoVisualSpectrum::VideoVisualSpectrum(AudioPlayer *audio, MythRender *render)
: VideoVisual(audio, render), m_range(1.0), m_scaleFactor(2.0),
m_falloff(3.0), m_barWidth(1)
{
m_numSamples = 64;
lin = (myth_fftw_float*) av_malloc(sizeof(myth_fftw_float)*FFTW_N);
rin = (myth_fftw_float*) av_malloc(sizeof(myth_fftw_float)*FFTW_N);
lout = (myth_fftw_complex*)
av_malloc(sizeof(myth_fftw_complex)*(FFTW_N/2+1));
rout = (myth_fftw_complex*)
av_malloc(sizeof(myth_fftw_complex)*(FFTW_N/2+1));
lplan = fftw_plan_dft_r2c_1d(FFTW_N, lin, (myth_fftw_complex_cast*)lout, FFTW_MEASURE);
rplan = fftw_plan_dft_r2c_1d(FFTW_N, rin, (myth_fftw_complex_cast*)rout, FFTW_MEASURE);
}
void fft_init()
{
fft_real_in = malloc(sizeof(double) * audio_period_size_frames);
fft_real_compressed = malloc(sizeof(double) * audio_period_size_frames);
fft_real_out = malloc(sizeof(double) * audio_period_size_frames);
fft_comp_in = fftw_malloc(sizeof(fftw_complex) * audio_period_size_frames);
fft_comp_compressed = fftw_malloc(sizeof(fftw_complex) * audio_period_size_frames);
fft_comp_equalized = fftw_malloc(sizeof(fftw_complex) * audio_period_size_frames);
fft_comp_out = fftw_malloc(sizeof(fftw_complex) * audio_period_size_frames);
fft_plan_forward = fftw_plan_dft_r2c_1d(audio_period_size_frames, fft_real_in, fft_comp_in, FFTW_ESTIMATE);
fft_plan_forward_compressed = fftw_plan_dft_r2c_1d(audio_period_size_frames, fft_real_compressed, fft_comp_compressed, FFTW_ESTIMATE);
fft_plan_backward = fftw_plan_dft_c2r_1d(audio_period_size_frames, fft_comp_equalized, fft_real_out, FFTW_ESTIMATE);
}
void
w_spectrogram_init (ddb_gtkui_widget_t *w) {
w_spectrogram_t *s = (w_spectrogram_t *)w;
load_config ();
deadbeef->mutex_lock (s->mutex);
s->samples = malloc (sizeof (double) * FFT_SIZE);
memset (s->samples, 0, sizeof (double) * FFT_SIZE);
s->data = malloc (sizeof (double) * FFT_SIZE);
memset (s->data, 0, sizeof (double) * FFT_SIZE);
if (s->drawtimer) {
g_source_remove (s->drawtimer);
s->drawtimer = 0;
}
s->samplerate = 44100.0;
s->height = 0;
s->low_res_end = 0;
s->log_index = (int *)malloc (sizeof (int) * MAX_HEIGHT);
memset (s->log_index, 0, sizeof (int) * MAX_HEIGHT);
for (int i = 0; i < FFT_SIZE; i++) {
// Hanning
//s->window[i] = (0.5 * (1 - cos (2 * M_PI * i/(FFT_SIZE-1))));
// Blackman-Harris
s->window[i] = 0.35875 - 0.48829 * cos(2 * M_PI * i /(FFT_SIZE)) + 0.14128 * cos(4 * M_PI * i/(FFT_SIZE)) - 0.01168 * cos(6 * M_PI * i/(FFT_SIZE));;
}
create_gradient_table (s, CONFIG_GRADIENT_COLORS, CONFIG_NUM_COLORS);
s->in = fftw_malloc (sizeof (double) * FFT_SIZE);
memset (s->in, 0, sizeof (double) * FFT_SIZE);
//s->out_real = fftw_malloc (sizeof (double) * FFT_SIZE);
s->out_complex = fftw_malloc (sizeof (fftw_complex) * FFT_SIZE);
//s->p_r2r = fftw_plan_r2r_1d (FFT_SIZE, s->in, s->out_real, FFTW_R2HC, FFTW_ESTIMATE);
s->p_r2c = fftw_plan_dft_r2c_1d (FFT_SIZE, s->in, s->out_complex, FFTW_ESTIMATE);
spectrogram_set_refresh_interval (s, CONFIG_REFRESH_INTERVAL);
deadbeef->mutex_unlock (s->mutex);
}
StreamInfo FFT::init(const ParameterMap& params, const StreamInfo& in)
{
int len = getIntParam("FFTLength", params);
if (len == 0)
len = in.size;
string w = getStringParam("FFTWindow", params);
if (w != "None")
{
if (w == "Hanning")
m_window = ehanningPeriodic(in.size);
else if (w == "Hamming")
m_window = ehammingPeriodic(in.size);
else
{
cerr << "FFT: invalid Window parameter value " << w << " ignore it !" << endl;
}
}
// init plan
m_nfft = len;
#ifdef WITH_FFTW3
double* inFFT = (double*) fftw_malloc(m_nfft*sizeof(double));
complex<double>* outFFT = (complex<double>*) fftw_malloc((m_nfft/2+1)*sizeof(complex<double>));
m_plan = fftw_plan_dft_r2c_1d(m_nfft,inFFT,(fftw_complex*)outFFT,FFTW_MEASURE);
fftw_free(inFFT);
fftw_free(outFFT);
#else
VectorXd infft(m_nfft);
VectorXcd outfft(m_nfft/2+1);
m_plan.fwd(outfft.data(),infft.data(),m_nfft);
#endif
return StreamInfo(in,len+2);
}
WhistleRecognizer::WhistleRecognizer()
{
for(int i = 0; i < WHISTLE_BUFF_LEN; ++i)
{
inputChannel0.push_front(0);
inputChannel1.push_front(0);
}
maxAutoCorrelationValue = 1522544.77f; // Default value for preconfigured whistle
cmpCnt = 0;
lastGameState = STATE_INITIAL;
lastTimeWhistleDetectedInBothChannels = 0;
// Allocate memeory for FFTW plans
whistleInput8kHz = (double*) fftw_malloc(sizeof(double) * WHISTLE_FFT_LEN);
fftDataIn = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * (WHISTLE_BUFF_LEN + 1));
corrBuff = (double*) fftw_malloc(sizeof(double) * WHISTLE_FFT_LEN);
// Create plans
// - after plan has been created, in and out buffer are set to zero
// - plan has to be created only once
// Creation of FFTW plans is not thread-safe, thus we need to synchronize with the other threads
// - This is only relevant for simulations that contain multiple robots
SYNC;
fft2048 = fftw_plan_dft_r2c_1d(WHISTLE_FFT_LEN, whistleInput8kHz, fftDataIn, FFTW_MEASURE); // build plan that fftw needs to compute the fft
ifft2048 = fftw_plan_dft_c2r_1d(WHISTLE_FFT_LEN, fftDataIn, corrBuff, FFTW_MEASURE); // build plan that fftw needs to compute the fft
// Load reference whistle (memory has already been allocated)
loadReferenceWhistle();
}
static inline void init_fft(struct pa_fft *pa_fft) {
if (!pa_fft)
return;
pa_fft->plan = fftw_plan_dft_r2c_1d(pa_fft->buffer_samples, pa_fft->buffer,
pa_fft->output, pa_fft->fft_flags);
}
int fft_forward(double* in, double* out, int N) {
fftw_plan plan;
fftw_complex* cout = (fftw_complex*)out;
plan = fftw_plan_dft_r2c_1d( N, in, cout, FFTW_ESTIMATE );
fftw_execute(plan);
return N;
}
//"forward" fourier transforms real array into complex array
void fftwf(int n, double*in, complex*out){
fftw_plan p = fftw_plan_dft_r2c_1d(n, in, (fftw_complex*)out, FFTW_ESTIMATE);
fftw_execute(p);
fftw_destroy_plan(p);
}
FFT::FFT(Table* window, SndObj* input, double scale,
int fftsize, int hopsize, double sr):
SndObj(input, fftsize, sr){
m_table = window;
m_hopsize = hopsize;
m_fftsize = fftsize;
m_frames = m_fftsize/m_hopsize;
m_sigframe = new double*[m_frames];
m_counter = new int[m_frames];
m_halfsize = m_fftsize/2;
m_fund = m_sr/m_fftsize;
int i;
for(i = 0; i < m_frames; i++){
m_sigframe[i] = new double[m_fftsize];
memset(m_sigframe[i], 0, m_fftsize*sizeof(double));
m_counter[i] = i*m_hopsize;
}
m_fftIn = (double*) fftw_malloc(sizeof(double) * m_fftsize);
m_fftOut = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * m_fftsize);
m_plan = fftw_plan_dft_r2c_1d(m_fftsize, m_fftIn, m_fftOut, FFTW_ESTIMATE);
memset(m_fftIn, 0, m_fftsize*sizeof(double));
AddMsg("scale", 21);
AddMsg("fft size", 22);
AddMsg("hop size", 23);
AddMsg("window", 24);
m_scale = scale;
m_norm = m_fftsize/m_scale;
m_cur =0;
}
static void initialize_circulant(hankel_matrix *h,
const double *F, R_len_t N, R_len_t L) {
R_len_t K = N - L + 1, i;
fftw_complex *ocirc;
fftw_plan p1, p2;
double *circ;
/* Allocate needed memory */
circ = (double*) fftw_malloc(N * sizeof(double));
ocirc = (fftw_complex*) fftw_malloc((N/2 + 1) * sizeof(fftw_complex));
/* Estimate the best plans for given input length */
p1 = fftw_plan_dft_r2c_1d(N, circ, ocirc, FFTW_ESTIMATE);
p2 = fftw_plan_dft_c2r_1d(N, ocirc, circ, FFTW_ESTIMATE);
/* Fill input buffer */
for (i = K-1; i < N; ++i)
circ[i - K + 1] = F[i];
for (i = 0; i < K-1; ++i) {
circ[L + i] = F[i];
}
/* Run the plan on input data */
fftw_execute(p1);
/* Cleanup and return */
fftw_free(circ);
h->circ_freq = ocirc;
h->r2c_plan = p1;
h->c2r_plan = p2;
h->window = L;
h->length = N;
}
void SpectralDifferenceODF::reset()
{
num_bins = (frame_size/2) + 1;
if(window) delete [] window;
window = new sample[frame_size];
for(int i = 0; i < frame_size; i++)
{
window[i] = 1.0;
}
hann_window(frame_size, window);
if(prev_amps) delete [] prev_amps;
prev_amps = new sample[num_bins];
for(int i = 0; i < num_bins; i++)
{
prev_amps[i] = 0;
}
if(in) fftw_free(in);
in = (sample*) fftw_malloc(sizeof(sample) * frame_size);
if(out) fftw_free(out);
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * num_bins);
fftw_destroy_plan(p);
p = fftw_plan_dft_r2c_1d(frame_size, in, out, FFTW_ESTIMATE);
}
void LPComplexODF::init()
{
coefs = new sample[order];
num_bins = (frame_size/2) + 1;
if(window) delete [] window;
window = new sample[frame_size];
for(int i = 0; i < frame_size; i++)
{
window[i] = 1.0;
}
hann_window(frame_size, window);
distances = new sample*[num_bins];
for(int i = 0; i < num_bins; i++)
{
distances[i] = new sample[order];
for(int j = 0; j < order; j++)
{
distances[i][j] = 0.0;
}
}
prev_frame = new fftw_complex[num_bins];
for(int i = 0; i < num_bins; i++)
{
prev_frame[i][0] = 0.0;
prev_frame[i][1] = 0.0;
}
in = (sample*) fftw_malloc(sizeof(sample) * frame_size);
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * num_bins);
p = fftw_plan_dft_r2c_1d(frame_size, in, out, FFTW_ESTIMATE);
}
// Constructor which creates a forward transform
FFTRealForward::FFTRealForward(int size, rsFloat *in, Complex *out)
{
//Lock the planner Mutex
boost::mutex::scoped_lock lock(plannerMutex);
plan = fftw_plan_dft_r2c_1d(size, in, reinterpret_cast<fftw_complex *>(out), FFTW_ESTIMATE);
//scoped_lock will unlock planner mutex here
}
Vector_double
stf::filter( const Vector_double& data, std::size_t filter_start,
std::size_t filter_end, const Vector_double &a, int SR,
stf::Func func, bool inverse ) {
if (data.size()<=0 || filter_start>=data.size() || filter_end > data.size()) {
std::out_of_range e("subscript out of range in stf::filter()");
throw e;
}
std::size_t filter_size=filter_end-filter_start+1;
Vector_double data_return(filter_size);
double SI=1.0/SR; //the sampling interval
double *in;
//fftw_complex is a double[2]; hence, out is an array of
//double[2] with out[n][0] being the real and out[n][1] being
//the imaginary part.
fftw_complex *out;
fftw_plan p1, p2;
//memory allocation as suggested by fftw:
in =(double *)fftw_malloc(sizeof(double) * filter_size);
out=(fftw_complex *)fftw_malloc(sizeof(fftw_complex) * ((int)(filter_size/2)+1));
// calculate the offset (a straight line between the first and last points):
double offset_0=data[filter_start];
double offset_1=data[filter_end]-offset_0;
double offset_step=offset_1 / (filter_size-1);
//fill the input array with data removing the offset:
for (std::size_t n_point=0;n_point<filter_size;++n_point) {
in[n_point]=data[n_point+filter_start]-(offset_0 + offset_step*n_point);
}
//plan the fft and execute it:
p1 =fftw_plan_dft_r2c_1d((int)filter_size,in,out,FFTW_ESTIMATE);
fftw_execute(p1);
for (std::size_t n_point=0; n_point < (unsigned int)(filter_size/2)+1; ++n_point) {
//calculate the frequency (in kHz) which corresponds to the index:
double f=n_point / (filter_size*SI);
double rslt= (!inverse? func(f,a) : 1.0-func(f,a));
out[n_point][0] *= rslt;
out[n_point][1] *= rslt;
}
//do the reverse fft:
p2=fftw_plan_dft_c2r_1d((int)filter_size,out,in,FFTW_ESTIMATE);
fftw_execute(p2);
//fill the return array, adding the offset, and scaling by filter_size
//(because fftw computes an unnormalized transform):
data_return.resize(filter_size);
for (std::size_t n_point=0; n_point < filter_size; ++n_point) {
data_return[n_point]=(in[n_point]/filter_size + offset_0 + offset_step*n_point);
}
fftw_destroy_plan(p1);
fftw_destroy_plan(p2);
fftw_free(in);fftw_free(out);
return data_return;
}
VALUE fft_1d(int argc, VALUE* argv, VALUE module) {
VALUE v, opts, size;
double *in;
fftw_complex *out;
fftw_plan fp;
int n;
rb_scan_args(argc, argv, "11", &v, &opts);
n = (int) get_count_of_data(v);
if (n == 0) {
rb_raise(rb_eException, "Can't use empty set of samples");
}
in = calloc(n, sizeof(double));
out = allocate_fftw_complex(n/2 + 1);
fp = fftw_plan_dft_r2c_1d(n, in, out, FFTW_ESTIMATE);
get_doubles_from_data(in, v);
fftw_execute(fp);
free(in);
fftw_destroy_plan(fp);
return ca_wrap_struct_class(out, n/2 + 1);
}
void Analyzer::init()
{
setState(Loading);
if (m_sampleSize != (quint32)KTunerConfig::segmentLength()) {
m_sampleSize = KTunerConfig::segmentLength();
m_outputSize = m_sampleSize + 1;
m_window.resize(m_sampleSize);
m_input.resize(2 * m_sampleSize);
m_output.resize(m_outputSize);
m_spectrum.resize(m_outputSize);
m_noiseSpectrum.resize(m_outputSize);
// FFTW and C++(99) complex types are binary compatible
auto output = reinterpret_cast<fftw_complex*>(m_output.data());
m_plan = fftw_plan_dft_r2c_1d(m_input.size(), m_input.data(), output, FFTW_MEASURE);
m_ifftPlan = fftw_plan_dft_c2r_1d(m_input.size(), output, m_input.data(), FFTW_ESTIMATE);
}
if (m_numSpectra != (quint32)KTunerConfig::numSpectra()) {
m_numSpectra = KTunerConfig::numSpectra();
m_currentSpectrum %= m_numSpectra;
m_spectrumHistory.fill(m_spectrum, m_numSpectra);
}
m_binFreq = qreal(KTunerConfig::sampleRate()) / m_input.size();
calculateWindow();
setNoiseFilter(KTunerConfig::enableNoiseFilter());
setFftFilter();
setState(Ready);
}
WindowedFFT(int size):size(size),size_c(size/2+1)
{
Data=(double*)fftw_malloc(sizeof(double)*size);
Data_c=(fftw_complex*)fftw_malloc(sizeof(fftw_complex)*size_c);
p1 = fftw_plan_dft_r2c_1d(size, Data, Data_c, FFTW_ESTIMATE); //FFTW_UNALIGNED
p2 = fftw_plan_dft_c2r_1d(size, Data_c, Data, FFTW_ESTIMATE);
}
FftAdapter::FftAdapter(unsigned int inFrameSize) : priv(new FftAdapterPrivate) {
frameSize = inFrameSize;
priv->inputReal = (double*)fftw_malloc(sizeof(double) * frameSize);
priv->outputComplex = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * frameSize);
boost::mutex::scoped_lock lock(fftwPlanMutex);
priv->plan = fftw_plan_dft_r2c_1d(frameSize, priv->inputReal, priv->outputComplex, FFTW_ESTIMATE);
}
void create_Signal_Struct(SignalStruct *signal, size_t length) {
assert(length>0);
size_t size;
if (length < INT_MAX) {
signal->size = length;
size = signal->size * sizeof(double);
} else {
exit(EXIT_FAILURE);
}
short i;
for (i = 0; i < NUMBER_OF_SIGNALS_COMPONENTS; i++) {
signal->componentsInTime[i] = fftw_malloc(size);
memset(signal->componentsInTime[i], 0, size);
signal->product[i] = fftw_malloc(size);
memset(signal->product[i], 0, size);
signal->componentsInFrequency[i] = fftw_malloc(signal->size * sizeof(fftw_complex));
memset(signal->componentsInFrequency[i], 0, signal->size * sizeof(fftw_complex));
signal->plan[i] = fftw_plan_dft_r2c_1d((int) signal->size, signal->componentsInTime[i],
signal->componentsInFrequency[i], FFTW_ESTIMATE);
}
for (; i < NUMBER_OF_SIGNALS; i++) {
signal->inTime[i] = fftw_malloc(size);
memset(signal->inTime[i], 0, size);
}
signal->powerSpectrumDensity = fftw_malloc(size);
memset(signal->powerSpectrumDensity, 0, size);
}
void calc_value(int pos) {
double fr[100000];
int first = pos*segment_len;
int len = segment_len;
memcpy(in, &data[first], sizeof(double)*len);
for (int i = 0; i < len; i++) {
in[i] *= 1.0*(1-cos(2*3.14159*i/(len-1)));
}
plan = fftw_plan_dft_r2c_1d(len, in, out, FFTW_ESTIMATE);
fftw_execute(plan);
for (int i = 0; i < len/2; i++) {
double x = sqrt(out[i][0]*out[i][0]+out[i][1]*out[i][1]);
double y = sqrt(out[i+1][0]*out[i+1][0]+out[i+1][1]*out[i+1][1]);
int a = i*sample_rate/len;
int b = (i+1)*sample_rate/len;
int p = b-a;
for (int j = a; j < b; j++) {
double v = x*(double)(b-j)/p+y*(double)(j-a)/p;
fr[j] = v;
}
}
for (int i = real_min_note; i <= real_max_note; i++) {
double f = fr[get_freq(i)];
if (rowmax[i] < f) rowmax[i] = f;
if (colmax[pos] < f) colmax[pos] = f;
freq[pos][i] = f;
}
}
FFTWProxyImplDouble(int n, double* timespace, gendouble2* freqspace)
{
forwardPlan = fftw_plan_dft_r2c_1d(
n, timespace, (fftw_complex*)freqspace, FFTW_ESTIMATE);
inversePlan = fftw_plan_dft_c2r_1d(
n, (fftw_complex*)freqspace, timespace, FFTW_ESTIMATE);
}
int dft_profiles (int N, double *in, fftw_complex *out)
// dft of profiles
{
// dft of profiles
///////////////////////////////////////////////////////////////////////
//printf ("%lf\n", in[0]);
//double *in;
//fftw_complex *out;
int i;
double inUse[N];
fftw_plan p;
//in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
//out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
p = fftw_plan_dft_r2c_1d(N, inUse, out, FFTW_MEASURE);
for (i = 0; i < N; i++)
{
inUse[i] = in[i];
}
fftw_execute(p);
fftw_destroy_plan(p);
//fftw_free(in);
//fftw_free(out);
return 0;
}
int plggdn_fft_init_fftw(plggdn_fft_t *fft, void *opaque) {
// init data memory, plggdn_fft_t stores only pointers,
// all memory operations take place in this implementation
fft->real_in = (plggdn_float*) fftw_malloc(sizeof(plggdn_float) * fft->N);
fft->complex_in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * fft->N);
fft->real_out = (plggdn_float*) fftw_malloc(sizeof(plggdn_float) * fft->N);
fft->complex_out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * fft->N);
plggdn_fft_fftw_attr *fftw_attr =
(plggdn_fft_fftw_attr*) malloc(sizeof(plggdn_fft_fftw_attr));
memset(fftw_attr, 0, sizeof(plggdn_fft_fftw_attr));
fft->opaque = fftw_attr;
// init plans
fftw_attr->p[FWD_R2C] = fftw_plan_dft_r2c_1d(fft->N, fft->real_in, fft->complex_out, FFTW_MEASURE);
fftw_attr->p[INV_C2R] = fftw_plan_dft_c2r_1d(fft->N, fft->complex_in, fft->real_out, FFTW_MEASURE);
fftw_attr->p[FWD_C2C] = fftw_plan_dft_1d(fft->N, fft->complex_in, fft->complex_out, FFTW_FORWARD, FFTW_MEASURE);
fftw_attr->p[INV_C2C] = fftw_plan_dft_1d(fft->N, fft->complex_in, fft->complex_out, FFTW_BACKWARD, FFTW_MEASURE);
return 0;
}
/**
* Create plan of given length for real-to-complex transform.
* All parameters are analogous to fftw_plan_dft_r2c_1d specification.
*/
inline fftwPlan(int Nfft, fftwDouble& input, fftwComplex& output, unsigned flags) {
#ifdef _OPENMP
#pragma omp critical
#endif
{
plan = fftw_plan_dft_r2c_1d(Nfft, &input, reinterpret_cast<fftw_complex*>(&output), flags);
}
}
LPSpectralDifferenceODF::LPSpectralDifferenceODF()
{
prev_amps = NULL;
in = NULL;
out = NULL;
p = fftw_plan_dft_r2c_1d(frame_size, in, out, FFTW_ESTIMATE);
init();
}
FFTStream_f(int size):size(size),size_c(size/2+1)
{
buffer=(double*)fftw_malloc(sizeof(double)*size);
buffer_c=(fftw_complex*)fftw_malloc(sizeof(fftw_complex)*size_c);
buffer_out=(double*)fftw_malloc(sizeof(double)*size_c);
p1 = fftw_plan_dft_r2c_1d(size, buffer, buffer_c, 0); //FFTW_UNALIGNED
//p2 = fftw_plan_dft_c2r_1d(size, buffer_c, buffer, 0);
}
static gboolean output_spectra_event (GfsEvent * event,
GfsSimulation * sim)
{
if ((* GFS_EVENT_CLASS (GTS_OBJECT_CLASS (gfs_output_spectra_class ())->parent_class)->event)
(event, sim)) {
GfsDomain * domain = GFS_DOMAIN (sim);
GfsOutputSpectra * v = GFS_OUTPUT_SPECTRA (event);
fftw_plan p;
Datawrite data;
data.fp = GFS_OUTPUT (event)->file->fp;
data.L = v->L;
data.kmax = init_kmax(v->L);
data.dir1 = v->dir[0];
data.dir2 = v->dir[1];
fill_cartesian_matrix( v->cgd, v->v, domain);
switch (v->Ndim) {
case 1: {
data.n1 = ( v->cgd->n[v->dir[0]] / 2 ) + 1;
data.out = fftw_malloc( sizeof(fftw_complex)*data.n1 );
p = fftw_plan_dft_r2c_1d( v->cgd->n[v->dir[0]], v->cgd->v, data.out, FFTW_ESTIMATE);
fftw_execute(p);
write_spectra_1D ( &data );
break;
}
case 2: {
data.n1 = v->cgd->n[v->dir[0]];
data.n2 = ( v->cgd->n[v->dir[1]] / 2 ) + 1;
data.out = fftw_malloc( sizeof(fftw_complex)*v->cgd->n[v->dir[0]]*data.n2 );
p = fftw_plan_dft_r2c_2d( v->cgd->n[v->dir[0]], v->cgd->n[v->dir[1]],
v->cgd->v, data.out, FFTW_ESTIMATE);
fftw_execute(p);
write_spectra_2D ( &data );
break;
}
case 3: {
data.n1 = v->cgd->n[0];
data.n2 = v->cgd->n[1];
data.n3 = ( v->cgd->n[2] / 2 ) + 1;
data.out = fftw_malloc( sizeof(fftw_complex)*v->cgd->n[0]*v->cgd->n[1]*data.n3 );
p = fftw_plan_dft_r2c_3d( v->cgd->n[0], v->cgd->n[1], v->cgd->n[2],
v->cgd->v, data.out, FFTW_ESTIMATE);
fftw_execute(p);
write_spectra_3D ( &data );
break;
}
default:
g_assert_not_reached ();
}
fftw_destroy_plan(p);
fftw_free ( data.out );
return TRUE;
}
return FALSE;
}
LPComplexODF::LPComplexODF()
{
prev_frame = NULL;
distances = NULL;
in = NULL;
out = NULL;
p = fftw_plan_dft_r2c_1d(frame_size, in, out, FFTW_ESTIMATE);
init();
}
FFTTransform(UInt buffersize, UInt inbuffers, UInt outbuffers, UInt overlapcount, UInt BuffersPerPeriod): OverlappedFilter3<NUMTYPE, double>(buffersize, (buffersize*BuffersPerPeriod/2+1)*2, inbuffers, outbuffers, overlapcount, BuffersPerPeriod)
{
Int l=((UInt)(this->PeriodSize() / 2) + 1);
//tmpdouble = (double*)fftw_malloc(sizeof(double)*buffersize);
tmpcomplex = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * l);
//coefficients = new double[l];
//cout << this->PeriodSize() << endl;
p1 = fftw_plan_dft_r2c_1d(this->PeriodSize(), this->tmpbuffer, tmpcomplex, 0); //FFTW_UNALIGNED
//p2 = fftw_plan_dft_c2r_1d(this->PeriodSize(), tmpcomplex, this->tmpbuffer, 0);
}
