void AKnockout::AllocateNewBuffers(unsigned int fftSize) {
unsigned int fftSize2=fftSize/2+1;
gInFIFO = new float [fftSize];
FFTRealBuffer=(float*)fftwf_malloc(sizeof(float)*fftSize);
gFFTworksp = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize2);
gOutputAccum = new float [fftSize];
gOutputAccum2 = new float [fftSize];
gAnaPhase1 = new float [fftSize2];
gAnaPhase2 = new float [fftSize2];
gAnaMagn = new float [fftSize2];
gInFIFO2 = new float [fftSize];
gFFTworksp2 = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize2);
gAnaMagn2 = new float [fftSize2];
gDecay = new float [fftSize2];
gDecay2 = new float [fftSize2];
window = new float [fftSize];
forward_sp1= fftwf_plan_dft_r2c_1d(fftSize, FFTRealBuffer , gFFTworksp,
FFTW_ESTIMATE);
forward_sp2= fftwf_plan_dft_r2c_1d(fftSize,FFTRealBuffer, gFFTworksp2,
FFTW_ESTIMATE);
backward_sp1=fftwf_plan_dft_c2r_1d(fftSize, gFFTworksp, FFTRealBuffer,
FFTW_ESTIMATE);
backward_sp2=fftwf_plan_dft_c2r_1d(fftSize, gFFTworksp2, FFTRealBuffer,
FFTW_ESTIMATE);
makelookup(fftSize);
}
FFTWProxyImplFloat(int n, float* timespace, genfloat2* freqspace)
{
forwardPlan = fftwf_plan_dft_r2c_1d(
n, timespace, (fftwf_complex*)freqspace, FFTW_ESTIMATE);
inversePlan = fftwf_plan_dft_c2r_1d(
n, (fftwf_complex*)freqspace, timespace, FFTW_ESTIMATE);
}
int main() {
float start[SIZE];
int i;
for (i=0; i<SIZE; i++) start[i] = (float)(i+1);
printf("Starting out: ");
for (i=0; i<SIZE; i++) printf(" %f ", (start[i])); printf("\n");
_Complex float middle[SIZE/2 + 1];
fftwf_plan plan = fftwf_plan_dft_r2c_1d(SIZE, start, (fftwf_complex*)middle, FFTW_ESTIMATE);
fftwf_execute(plan);
fftwf_destroy_plan(plan);
printf("Done with forward transform: ");
for (i=0; i< SIZE/2 + 1; i++) printf(" %g+%gi ", __real__ (middle[i]), __imag__ (middle[i]));
printf("\n");
float end[SIZE];
fftwf_plan plan2 = fftwf_plan_dft_c2r_1d(SIZE, (fftwf_complex*)middle, end, FFTW_ESTIMATE);
fftwf_execute(plan2);
fftwf_destroy_plan(plan2);
printf("Done with reverse transform transform: ");
for (i=0; i<SIZE; i++) printf(" %fi ", (end[i]));
printf("\n");
}
equalizer::equalizer(int bands,
const int hnSize,
const int HwSize)
: size_(bands),hnSize_(hnSize),HwSize_(HwSize),verbose_(false),wnd_(0) {
bands_ = new float[size_];
freqs_ = new float[size_];
for (int i=0;i<size_;++i) {
bands_[i]=1.0;
freqs_[i]=0.0;
}
// initialize FFT transformers
// Buffer that holds the frequency domain data
Hw_ = reinterpret_cast<fftwf_complex*>
(fftwf_malloc(sizeof(fftwf_complex)*HwSize_));
memset(Hw_,0,HwSize_*sizeof(fftwf_complex));
// Even if the size of h(n) is hnSize_, we use HwSize because zero
// padding is to be performed
hn_ = reinterpret_cast<float*>(fftwf_malloc(sizeof(float)*HwSize_));
memset(hn_,0,sizeof(float)*HwSize_);
ifft_ = fftwf_plan_dft_c2r_1d(HwSize_,Hw_,hn_,FFTW_MEASURE);
fft_ = fftwf_plan_dft_r2c_1d(HwSize_,hn_,Hw_,FFTW_MEASURE);
hanning();
//rectangular();
}
GOSoundReverbPartition::GOSoundReverbPartition(unsigned size, unsigned cnt, unsigned start_pos) :
m_PartitionSize(size),
m_PartitionCount(cnt),
m_fftwTmpReal(0),
m_fftwTmpComplex(0),
m_TimeToFreq(0),
m_FreqToTime(0),
m_Input(0),
m_Output(0),
m_InputPos(start_pos),
m_InputStartPos(start_pos),
m_OutputPos(0),
m_InputHistory(),
m_IRData(),
m_InputHistoryPos(0)
{
m_fftwTmpReal = new float[m_PartitionSize * 2];
m_fftwTmpComplex = new fftwf_complex[m_PartitionSize + 1];
m_TimeToFreq = fftwf_plan_dft_r2c_1d(2 * m_PartitionSize, m_fftwTmpReal, m_fftwTmpComplex, FFTW_ESTIMATE);
m_FreqToTime = fftwf_plan_dft_c2r_1d(2 * m_PartitionSize, m_fftwTmpComplex, m_fftwTmpReal, FFTW_ESTIMATE);
assert(m_TimeToFreq);
assert(m_FreqToTime);
m_Input = new float[m_PartitionSize];
m_Output = new float[2 * m_PartitionSize];
for(unsigned i = 0; i < m_PartitionCount; i++)
m_InputHistory.push_back(new fftwf_complex[m_PartitionSize + 1]);
for(unsigned i = 0; i < m_PartitionCount; i++)
m_IRData.push_back(NULL);
Reset();
}
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);
}
}
Convolver::Convolver(unsigned long int size) : _size(size), _fourier_size(size/2+1)
{
this->real = (float *) fftwf_malloc(sizeof(float) * this->_size);
this->fourier = (fftwf_complex *) fftwf_malloc(sizeof(fftwf_complex) * this->_fourier_size);
this->forward = fftwf_plan_dft_r2c_1d(this->_size, this->real, this->fourier,
FFTW_MEASURE);
this->backward = fftwf_plan_dft_c2r_1d(this->_size, this->fourier, this->real,
FFTW_MEASURE);
}
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);
}
// create an instance of the decoder
// blocksize is fixed over the lifetime of this object for performance reasons
decoder_impl(unsigned blocksize=8192): N(blocksize), halfN(blocksize/2) {
#ifdef USE_FFTW3
// create FFTW buffers
lt = (float*)fftwf_malloc(sizeof(float)*N);
rt = (float*)fftwf_malloc(sizeof(float)*N);
dst = (float*)fftwf_malloc(sizeof(float)*N);
dftL = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*N);
dftR = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*N);
src = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*N);
loadL = fftwf_plan_dft_r2c_1d(N, lt, dftL,FFTW_MEASURE);
loadR = fftwf_plan_dft_r2c_1d(N, rt, dftR,FFTW_MEASURE);
store = fftwf_plan_dft_c2r_1d(N, src, dst,FFTW_MEASURE);
#else
// create lavc fft buffers
lt = (float*)av_malloc(sizeof(FFTSample)*N);
rt = (float*)av_malloc(sizeof(FFTSample)*N);
dftL = (FFTComplexArray*)av_malloc(sizeof(FFTComplex)*N*2);
dftR = (FFTComplexArray*)av_malloc(sizeof(FFTComplex)*N*2);
src = (FFTComplexArray*)av_malloc(sizeof(FFTComplex)*N*2);
fftContextForward = (FFTContext*)av_malloc(sizeof(FFTContext));
memset(fftContextForward, 0, sizeof(FFTContext));
fftContextReverse = (FFTContext*)av_malloc(sizeof(FFTContext));
memset(fftContextReverse, 0, sizeof(FFTContext));
ff_fft_init(fftContextForward, 13, 0);
ff_fft_init(fftContextReverse, 13, 1);
#endif
// resize our own buffers
frontR.resize(N);
frontL.resize(N);
avg.resize(N);
surR.resize(N);
surL.resize(N);
trueavg.resize(N);
xfs.resize(N);
yfs.resize(N);
inbuf[0].resize(N);
inbuf[1].resize(N);
for (unsigned c=0;c<6;c++) {
outbuf[c].resize(N);
filter[c].resize(N);
}
sample_rate(48000);
// generate the window function (square root of hann, b/c it is applied before and after the transform)
wnd.resize(N);
for (unsigned k=0;k<N;k++)
wnd[k] = sqrt(0.5*(1-cos(2*PI*k/N))/N);
current_buf = 0;
memset(inbufs, 0, sizeof(inbufs));
memset(outbufs, 0, sizeof(outbufs));
// set the default coefficients
surround_coefficients(0.8165,0.5774);
phase_mode(0);
separation(1,1);
steering_mode(true);
}
inline void irfft(CDEVector<float>::Type &X, DEVector<float>::Type &x)
{
int fftsize = 2*(X.length()-1);
// calc IFFT
x.resize(fftsize);
fftwf_plan p1 = fftwf_plan_dft_c2r_1d(fftsize,
reinterpret_cast<fftwf_complex*>( &X(1) ),
&x(1), FFTW_ESTIMATE);
fftwf_execute(p1);
fftwf_destroy_plan(p1);
}
FFTwrapper::FFTwrapper(int fftsize_)
{
fftsize = fftsize_;
time = new fftw_real[fftsize];
fft = new fftwf_complex[fftsize + 1];
planfftw = fftwf_plan_dft_r2c_1d(fftsize,
time,
fft,
FFTW_ESTIMATE);
planfftw_inv = fftwf_plan_dft_c2r_1d(fftsize,
fft,
time,
FFTW_ESTIMATE);
}
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;
}
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);
}
}
scfft * scfft_create(size_t fullsize, size_t winsize, SCFFT_WindowFunction wintype,
float *indata, float *outdata, SCFFT_Direction forward, SCFFT_Allocator & alloc)
{
char * chunk = (char*) alloc.alloc(sizeof(scfft) + scfft_trbufsize(fullsize));
if (!chunk)
return NULL;
scfft * f = (scfft*)chunk;
float *trbuf = (float*)(chunk + sizeof(scfft));
f->nfull = fullsize;
f->nwin = winsize;
f->log2nfull = LOG2CEIL(fullsize);
f->log2nwin = LOG2CEIL( winsize);
f->wintype = wintype;
f->indata = indata;
f->outdata = outdata;
f->trbuf = trbuf;
// Buffer is larger than the range of sizes we provide for at startup; we can get ready just-in-time though
if (fullsize > SC_FFT_MAXSIZE)
scfft_ensurewindow(f->log2nfull, f->log2nwin, wintype);
#if SC_FFT_FFTW
if(forward)
f->plan = fftwf_plan_dft_r2c_1d(fullsize, trbuf, (fftwf_complex*) trbuf, FFTW_ESTIMATE);
else
f->plan = fftwf_plan_dft_c2r_1d(fullsize, (fftwf_complex*) trbuf, outdata, FFTW_ESTIMATE);
#endif
// The scale factors rescale the data to unity gain. The old Green lib did this itself, meaning scalefacs would here be 1...
if(forward){
#if SC_FFT_VDSP
f->scalefac = 0.5f;
#else // forward FFTW and Green factor
f->scalefac = 1.f;
#endif
} else { // backward FFTW and VDSP factor
#if SC_FFT_GREEN
f->scalefac = 1.f;
#else // fftw, vdsp
f->scalefac = 1.f / fullsize;
#endif
}
memset(trbuf, 0, scfft_trbufsize(fullsize));
return f;
}
CDecoder::CDecoder(IDecodeResult* _listener)
{
dump = 0;
_decodeResultListener = _listener;
s32CentreFreq=RX_CARRIER_FREQ;
fSampleRate=SAMPLE_RATE;
fVCOPhase=0.0F;
nFIRPos=RX_MATCHED_FILTER_SIZE-1;
nPeakPos=0;
nNewPeakPos=0;
nBitPos=0;
fBitPhasePos=0.0F;
csLastIQ.fRe = 0.0F;
csLastIQ.fIm = 0.0F;
fEnergyOut=1.0F;
u32BitAcc=0;
nBitCount=0;
nByteCount=0;
nDownSampleHistIndex=0;
nDownSampleCount=0;
_centreBin = 0;
_isDecoded = FALSE;
_fftInvIn = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * INVERSE_FFT_SIZE);
_fftInvOut = (float*) fftwf_malloc(sizeof(float) * INVERSE_FFT_SIZE);
_fftInvPlan = fftwf_plan_dft_c2r_1d(INVERSE_FFT_SIZE, _fftInvIn, _fftInvOut, FFTW_MEASURE);
for (int i=0;i<RX_SINCOS_SIZE;i++)
{
afSin[i]=(FLOAT)sin(i*2.0*PI/RX_SINCOS_SIZE);
afCos[i]=(FLOAT)cos(i*2.0*PI/RX_SINCOS_SIZE);
}
for (int i=0;i<RX_MATCHED_FILTER_SIZE;i++)
{
acsHistory[i].fRe=0.0F;
acsHistory[i].fIm=0.0F;
}
for (int i=0;i<SAMPLES_PER_BIT+2;i++)
{
afSyncEnergyAvg[i]=0.0F;
}
}
/** Instantiate the plugin.
*
* This function initialises the plugin. It includes allocating memory
* and fftw plans and saving them to a datastructure for later
* reference.
*
* @param descriptor argument of unknown significance
* @param rate the amount of samples per second thius plusin operates at
* @param bundle_path argument of unknownn significance
* @param features argument of unknown significance
*
* @return an LV2_Handle representation of the datastructure
*/
LV2_Handle instantiate(/*@unused@*/ const LV2_Descriptor *
descriptor, /*@unused@*/ double rate,
/*@unused@*/ const char *bundle_path,
/*@unused@*/ const LV2_Feature* const *features)
{
Amp *amp = malloc(sizeof(Amp));
assert(amp != NULL);
amp->complex_buffer =
fftwf_malloc(sizeof(fftwf_complex) * COMPLEX_SIZE);
assert(amp->complex_buffer != NULL);
amp->kernel_buffer =
fftwf_malloc(sizeof(fftwf_complex) * COMPLEX_SIZE);
assert(amp->kernel_buffer != NULL);
amp->fourier_buffer = fftwf_malloc(sizeof(float) * FOURIER_SIZE);
assert(amp->fourier_buffer != NULL);
amp->in_buffer = init_buffer(BUFFER_SIZE, FOURIER_SIZE);
assert(amp->in_buffer != NULL);
amp->previous_buffer = malloc(sizeof(float) * FOURIER_SIZE);
assert(amp->previous_buffer != NULL);
amp->out_buffer = init_buffer(BUFFER_SIZE, FOURIER_SIZE);
assert(amp->out_buffer != NULL);
amp->buffer_index = 0;
set_inner_product(&(amp->convolve_func));
amp->forward =
fftwf_plan_dft_r2c_1d(FOURIER_SIZE, amp->fourier_buffer,
amp->complex_buffer, FFTW_ESTIMATE);
assert(amp->forward != NULL);
amp->backward =
fftwf_plan_dft_c2r_1d(FOURIER_SIZE, amp->kernel_buffer,
amp->fourier_buffer, FFTW_ESTIMATE);
assert(amp->backward != NULL);
#ifdef __OPENMP__
omp_set_num_threads(omp_get_num_procs());
#endif
return (LV2_Handle) amp;
}
/* 1-D IFFT */
void FFTW_(ifft)(real *r, real *x, long n)
{
#ifdef USE_FFTW
#if defined(TH_REAL_IS_DOUBLE)
fftw_complex *in = (fftw_complex*)x;
fftw_plan p = fftw_plan_dft_c2r_1d(n, in, r, FFTW_ESTIMATE);
fftw_execute(p);
fftw_destroy_plan(p);
#else
fftwf_complex *in = (fftwf_complex*)x;
fftwf_plan p = fftwf_plan_dft_c2r_1d(n, in, r, FFTW_ESTIMATE);
fftwf_execute(p);
fftwf_destroy_plan(p);
#endif
#else
THError("ifft : FFTW Library was not found in compile time\n");
#endif
}
void sf_cosft_init(int n1_in)
/*< initialize >*/
{
n1 = n1_in;
nt = 2*kiss_fft_next_fast_size(n1-1);
nw = nt/2+1;
p = sf_floatalloc (nt);
pp = (kiss_fft_cpx*) sf_complexalloc(nw);
#ifdef SF_HAS_FFTW
cfg = fftwf_plan_dft_r2c_1d(nt, p, (fftwf_complex *) pp,
FFTW_ESTIMATE);
icfg = fftwf_plan_dft_c2r_1d(nt, (fftwf_complex *) pp, p,
FFTW_ESTIMATE);
#else
forw = kiss_fftr_alloc(nt,0,NULL,NULL);
invs = kiss_fftr_alloc(nt,1,NULL,NULL);
#endif
}
void fftw1d_plan(fftwplan_h *h, int n)
{
fftwplan_t *tt;
void *pi; void *po; int nr, nc;
tt = calloc(1, sizeof(fftwplan_t));
//1. real/complex
nr = n; nc=nr/2+1;
pi = calloc(nr, sizeof(float));
po = calloc(nc, sizeof(complex float));
tt->r2c = fftwf_plan_dft_r2c_1d(nr, pi, po, FFTW_PATIENT);
tt->c2r = fftwf_plan_dft_c2r_1d(nr, po, pi, FFTW_PATIENT);
free(pi); free(po);
//2. complex/complex
pi = calloc(n, sizeof(complex float));
po = calloc(n, sizeof(complex float));
tt->fwd = fftwf_plan_dft_1d(n, pi, po, FFTW_FORWARD, FFTW_PATIENT);
tt->rvs = fftwf_plan_dft_1d(n, pi, po, FFTW_BACKWARD, FFTW_PATIENT);
free(pi); free(po);
*h = (fftwplan_h)tt;
}
int scfft_create(scfft *f, unsigned int fullsize, unsigned int winsize, short wintype, float *indata, float *outdata, float *trbuf, bool forward){
f->nfull = fullsize;
f->nwin = winsize;
f->log2nfull = LOG2CEIL(fullsize);
f->log2nwin = LOG2CEIL( winsize);
f->wintype = wintype;
f->indata = indata;
f->outdata = outdata;
f->trbuf = trbuf;
// Buffer is larger than the range of sizes we provide for at startup; we can get ready just-in-time though
if (fullsize > SC_FFT_MAXSIZE){
scfft_ensurewindow(f->log2nfull, f->log2nwin, wintype);
}
#if SC_FFT_FFTW
if(forward)
f->plan = fftwf_plan_dft_r2c_1d(fullsize, trbuf, (fftwf_complex*) trbuf, FFTW_ESTIMATE);
else
f->plan = fftwf_plan_dft_c2r_1d(fullsize, (fftwf_complex*) trbuf, outdata, FFTW_ESTIMATE);
#endif
// The scale factors rescale the data to unity gain. The old Green lib did this itself, meaning scalefacs would here be 1...
if(forward){
#if SC_FFT_VDSP
f->scalefac = 0.5f;
#else // forward FFTW factor
f->scalefac = 1.f;
#endif
}else{ // backward FFTW and VDSP factor
f->scalefac = 1.f / fullsize;
}
memset(trbuf, 0, scfft_trbufsize(fullsize));
return 0;
}
// Processes a sound file to include the response in the recorder
// track. The response is not interpolated with a successive
// response. A Fast Fourier Transform is used to transfer both the
// dry signal and the impulse response to the frequency domain to
// reduce the complexity (= speed up) of the convolution operation.
// An additional argument specifies whether to optionally fade in
// or fade out the input signal to help with the interpolation
// of successive key-frames.
RecorderTrack* RecorderTrack::Process(SoundFile* const sound_file,
Fade fade) const {
const RecorderTrack& _this = *this;
const unsigned int M = this->getLength();
const unsigned int N = sound_file->sample_length;
const unsigned int MN = M+N+1;
const unsigned int MNh = MN/2+1;
float* a = (float*) fftwf_malloc(sizeof (float) * MN);
memset(a,0,sizeof(float)*MN);
memcpy(a,&_this[0],sizeof(float)*M);
fftwf_complex* A = (fftwf_complex *) fftwf_malloc (
sizeof (fftwf_complex) * MNh);
memset(A,0,sizeof (fftwf_complex) * MNh);
fftwf_plan fft_plan1 = fftwf_plan_dft_r2c_1d(
MN,a,A,FFTW_ESTIMATE);
fftwf_execute(fft_plan1);
fftwf_free(a);
float* b = (float*) fftwf_malloc(sizeof (float) * MN);
memset(b,0,sizeof(float)*MN);
memcpy(b,sound_file->data,sizeof(float)*N);
if ( fade != CONSTANT ) {
float factor = fade == FADE_OUT ? 1.0f : 0.0f;
float df = (fade == FADE_OUT ? -1.0f : 1.0f) /
(float)sound_file->sample_length;
for ( unsigned int i = 0;
i < sound_file->sample_length;
++ i ) {
b[i] *= factor;
factor += df;
}
}
fftwf_complex* B = (fftwf_complex *) fftwf_malloc (
sizeof (fftwf_complex) * MNh);
memset(B,0,sizeof (fftwf_complex) * MNh);
fftwf_plan fft_plan2 = fftwf_plan_dft_r2c_1d(
MN,b,B,FFTW_ESTIMATE);
fftwf_execute(fft_plan2);
fftwf_free(b);
float scale = 1.0f / (float)MN;
for ( unsigned int i = 0; i < MNh; ++ i ) {
float re = (A[i][0] * B[i][0] - A[i][1] * B[i][1]) * scale;
float im = (A[i][0] * B[i][1] + A[i][1] * B[i][0]) * scale;
A[i][0] = re;
A[i][1] = im;
}
fftwf_free(B);
float* c = (float*) fftwf_malloc(sizeof (float) * MN);
memset(c,0,sizeof(float)*MN);
fftwf_plan inv_fft_plan = fftwf_plan_dft_c2r_1d(
MN,A,c,FFTW_ESTIMATE);
fftwf_execute(inv_fft_plan);
fftwf_free(A);
RecorderTrack* result = new RecorderTrack();
RecorderTrack& _result = *result;
for ( unsigned int i = 0; i < MN; ++ i ) {
_result[i+sound_file->offset] = c[i];
}
fftwf_free(c);
fftwf_destroy_plan (fft_plan1);
fftwf_destroy_plan (fft_plan2);
fftwf_destroy_plan (inv_fft_plan);
return result;
}
/**
@param hFactor corresponds to the bandwidth factor
@param dataSrc is the trace of the raw data
@remarks the FFTW function transform the area such that the area output is the area input multiplied by fftLen. So we have to corret it.
**/
QMap<double, double> MetropolisVariable::generateHisto(QVector<double>& dataSrc, int fftLen, double hFactor, double tmin, double tmax)
{
int inputSize = fftLen;
int outputSize = 2 * (inputSize / 2 + 1);
double sigma = dataStd(dataSrc);
QMap<double, double> result;
if (sigma==0) {
qDebug()<<"MetropolisVariable::generateHisto sigma=0";
return result;
}
double h = hFactor * 1.06 * sigma * pow(dataSrc.size(), -1.f/5.f);
double a = vector_min_value(dataSrc) - 4.f * h;
double b = vector_max_value(dataSrc) + 4.f * h;
double delta = (b - a) / fftLen;
float* input = generateBufferForHisto(dataSrc, fftLen, hFactor);
float* output = (float*) fftwf_malloc(outputSize * sizeof(float));
/*
double areaTot = 0.;
for(int i=0; i<inputSize; ++i) {
areaTot += input[i];
}
qDebug()<<"MetropolisVariable::generateHisto areaTot ="<<areaTot<<" a="<<a<<" b="<<b;
qDebug()<<areaTot;
*/
if(input != 0) {
// ----- FFT -----
fftwf_plan plan_forward = fftwf_plan_dft_r2c_1d(inputSize, input, (fftwf_complex*)output, FFTW_ESTIMATE);
fftwf_execute(plan_forward);
for(int i=0; i<outputSize/2; ++i) {
double s = 2.f * M_PI * i / (b-a);
double factor = expf(-0.5f * s * s * h * h);
output[2*i] *= factor;
output[2*i + 1] *= factor;
}
fftwf_plan plan_backward = fftwf_plan_dft_c2r_1d(inputSize, (fftwf_complex*)output, input, FFTW_ESTIMATE);
fftwf_execute(plan_backward);
// ----- FFT Buffer to result map -----
/*
areaTot =0.;
for(int i=0; i<inputSize; ++i) {
areaTot += input[i];
}
//qDebug()<<"MetropolisVariable::generateHisto areaTot ="<<areaTot<<" a="<<a<<" b="<<b;
//qDebug()<<areaTot/inputSize;
*/
for(int i=0; i<inputSize; ++i) {
double t = a + (double)i * delta;
if(t >= tmin && t<= tmax) {
result[t] = input[i];
}
}
fftwf_free(input);
fftwf_free(output);
result = equal_areas(result, 1.); // normalize the output area du to the fftw and the case (t >= tmin && t<= tmax)
}
return result; // return a map between a and b with a step delta = (b - a) / fftLen;
}
// new
void *firbank_new(t_symbol *s, short argc, t_atom *argv) {
// scope vars
t_firbank *x;
t_symbol* default_buffer;
int default_filters;
int default_iomap;
int default_channel_1;
int default_channel_2;
int i, j, c;
// instantiate
x = object_alloc(firbank_class);
if(!x){
return NULL;
}
// setup defaults
/*
x->autosplit = 0;
x->overlap = 0.5;
x->overlap_power = 1.0;
x->rc = 0.9;
x->template = NULL;
x->bands = NULL;
x->iomap = NULL;
*/
x->framesize = 512;
x->n = 1;
x->m = 16;
x->k = 16;
x->v = 0;
x->filters = NULL;
x->filter_states = NULL;
x->input_copy = NULL;
x->input = NULL;
x->output = NULL;
x->w = NULL;
// initialization parsing state
default_buffer = NULL;
default_iomap = 1;
default_filters = 1;
default_channel_1 = 0;
default_channel_2 = 1;
// read arguments
for(i = 0; i < argc; i++) {
if(argv[i].a_type == A_SYM) {
// look for @n
if(strcmp(argv[i].a_w.w_sym->s_name, "@n") == 0) {
i++;
if(i < argc && argv[i].a_type == A_LONG) {
x->n = argv[i].a_w.w_long;
} else {
object_post((t_object *)x, "firbank~: expected int for @n");
}
}
// look for @k
else if(strcmp(argv[i].a_w.w_sym->s_name, "@k") == 0) {
i++;
if(i < argc && argv[i].a_type == A_LONG) {
x->k = argv[i].a_w.w_long;
} else {
object_post((t_object *)x, "firbank~: expected int for @k");
}
}
// look for @m
else if(strcmp(argv[i].a_w.w_sym->s_name, "@m") == 0) {
i++;
if(i < argc && argv[i].a_type == A_LONG) {
x->m = argv[i].a_w.w_long;
} else {
object_post((t_object *)x, "firbank~: expected int for @m");
}
}
// look for @framesize
else if(strcmp(argv[i].a_w.w_sym->s_name, "@framesize") == 0) {
i++;
if(i < argc && argv[i].a_type == A_LONG) {
x->framesize = argv[i].a_w.w_long;
} else {
object_post((t_object *)x, "firbank~: expected int for @framesize");
}
}
// look for @buffer
else if(strcmp(argv[i].a_w.w_sym->s_name, "@buffer") == 0) {
i++;
if(i < argc && argv[i].a_type == A_SYM) {
default_buffer = argv[i].a_w.w_sym; // _sym_to_buffer(argv[i].a_w.w_sym);
//x->autosplit = 0;
} else {
object_post((t_object *)x, "firbank~: expected symbol for @buffer");
}
}
// look for @channel
else if(strcmp(argv[i].a_w.w_sym->s_name, "@channel") == 0) {
default_channel_1 = -1;
default_channel_2 = -1;
i++;
if(i < argc && argv[i].a_type == A_LONG) {
default_channel_1 = argv[i].a_w.w_long;
if(i + 1 < argc && argv[i+1].a_type == A_LONG) {
i++;
default_channel_2 = argv[i].a_w.w_long;
} else {
default_channel_2 = -1;
}
} else {
object_post((t_object *)x, "firbank~: expected int for @channel");
}
}
// look for @filter
/*
if(strcmp(argv[i].a_w.w_sym->s_name, "@filter") == 0) {
// @todo
}
*/
// look for @mode
/*
if(strcmp(argv[i].a_w.w_sym->s_name, "@mode") == 0) {
i++;
if(strcmp(argv[i].a_w.w_sym->s_name, "complex") == 0) {
default_mode = FIRBANK_MODE_COMPLEX;
} else if(strcmp(argv[i].a_w.w_sym->s_name, "polar") == 0) {
default_mode = FIRBANK_MODE_POLAR;
} else if(strcmp(argv[i].a_w.w_sym->s_name, "timedomain") == 0) {
default_mode = FIRBANK_MODE_POLAR;
} else {
object_post((t_object *)x, "firbank~: expected symbol, 'complex', 'polar', or 'timedomain' for @mode");
}
}
*/
/*
// look for @offset
if(strcmp(argv[i].a_w.w_sym->s_name, "@offset") == 0) {
// todo
}
// look for @iomap
if(strcmp(argv[i].a_w.w_sym->s_name, "@iomap") == 0) {
}
// look for @autosplit
if(strcmp(argv[i].a_w.w_sym->s_name, "@autosplit") == 0) {
}
// look for @overlap
if(strcmp(argv[i].a_w.w_sym->s_name, "@overlap") == 0) {
}
// look for @rc
if(strcmp(argv[i].a_w.w_sym->s_name, "@rc") == 0) {
}
*/
}
}
if(x->m) {
// post("firbank~: allocating %d filter states, tail %d samples", x->m, x->framesize / 2);
x->filter_states = (t_fir_state*)malloc(sizeof(t_fir_state)*x->m);
for(i = 0; i < x->m; i++) {
x->filter_states[i].tail = (float*)fftwf_malloc(sizeof(float) * x->framesize / 2);
memset(x->filter_states[i].tail, 0, sizeof(float) * x->framesize / 2);
}
}
/*
if(x->autosplit) {
// configure...
object_post((t_object *)x, "firbank~: autosplit mode not supported yet");
}
*/
// setup filters if not from initialization
if(default_filters && default_buffer != NULL) {
// post("firbank~: setting up %d filters with framesize %d, channels (%d, %d)", x->k, x->framesize, default_channel_1, default_channel_2);
x->filters = (t_fir*)malloc(sizeof(t_fir)*x->k);
for(i = 0; i < x->k; i++) {
x->filters[i].buffer = default_buffer;
x->filters[i].channel_1 = default_channel_1;
x->filters[i].channel_2 = default_channel_2;
x->filters[i].offset = i * x->framesize;
}
} else {
object_post((t_object *)x, "firbank~: no buffer specified");
}
// setup iomap if not from initialization
if(default_iomap) {
// post("firbank~: initializing input-output map...");
for(i = 0; i < x->n; i++) {
for(j = 0; j < x->k; j++) {
c = (j*(x->m/x->k))+i;
if(c < x->m) {
x->filter_states[c].o = c; // output channel
x->filter_states[c].k = j; // filter
x->filter_states[c].i = i; // input channel
// post("firbank~: input: %d, filter %d, output %d", x->filter_states[c].i, x->filter_states[c].k, x->filter_states[c].o);
}
}
}
}
// setup fftw
x->x_forward_t = (float*)fftwf_malloc(sizeof(float) * (x->framesize + 2)); // two extra so fftw can work its in-place magic
x->x_forward_c = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * (x->framesize / 2 + 1)); // n/2+1 complex numbers (dc is first, nyquist last)
x->x_inverse_t = (float*)fftwf_malloc(sizeof(float) * (x->framesize + 2));
x->x_inverse_c = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * (x->framesize / 2 + 1)); // n/2+1 complex numbers (dc is first, nyquist last)
x->input_copy = (float*)fftwf_malloc(sizeof(float) * (x->framesize / 2) * x->n);
memset(x->x_forward_t, 0, sizeof(float) * (x->framesize));
memset(x->x_inverse_t, 0, sizeof(float) * (x->framesize));
// post("firbank~: preparing fftw plan...");
x->x_forward = fftwf_plan_dft_r2c_1d(x->framesize,
x->x_forward_t, x->x_forward_c,
FFTW_MEASURE
);
x->x_inverse = fftwf_plan_dft_c2r_1d(x->framesize,
x->x_inverse_c, x->x_inverse_t,
FFTW_MEASURE
);
// post("firbank~: done.");
x->w = (t_int**)malloc(sizeof(t_int*) * (x->n + x->m + 2));
x->input = (float**)malloc(sizeof(float*) * x->n);
x->output = (float**)malloc(sizeof(float*) * x->m);
// don't share inlet and outlet buffers
// this doesn't work!
// x->x_obj.z_misc = Z_NO_INPLACE;
// allocate inlets
dsp_setup((t_pxobject *)x, x->n);
// allocate outlets
for(i = 0; i < x->m; i++) {
outlet_new((t_object *)x, "signal"); // type of outlet: "signal"
}
return (x);
}
int main()
{
if (FILE* wisdomfile = fopen("wisdom.wis","r"))
{
fftwf_import_wisdom_from_file(wisdomfile);
fclose(wisdomfile);
}
const int N[] = {32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072};
const int sizeN = 13;
int cfft[sizeN];
int nfft[sizeN];
double t;
double tavg;
double tfprev;
double tbprev;
for (int l = 0; l < sizeN; l++)
{
cfft[l] = N[l]+1;
nfft[l] = N[l]*2;
}
FILE *fp = fopen("fftw.csv","w");
for (int l = 0; l < sizeN; l++)
{
printf("\n\nTiming N = %u, cfft = %u\n",N[l],cfft[l]);
float *a = new float[nfft[l]];
fftwf_complex *b = (fftwf_complex*)fftwf_malloc(cfft[l]*sizeof(fftwf_complex));
fftwf_plan fwd;
fftwf_plan bck;
int trial;
float temp;
fprintf(fp,"%u, ",N[l]);
//ESTIMATE --------------- ---------------
temp = (float)get_time();
for (int i = 0; i < nfft[i]; i++)
a[i] = temp;
float* bptr = (float*)b;
for (int i = 0; i < 2*cfft[i]; i++)
bptr[i] = temp;
printf("ESTIMATE: \n");
fwd = fftwf_plan_dft_r2c_1d(nfft[l],a,b,FFTW_ESTIMATE);
bck = fftwf_plan_dft_c2r_1d(nfft[l],b,a,FFTW_ESTIMATE);
t = 0;
for (trial = 0; trial < MAX_TRIALS; trial++)
{
if (t > MAX_TIME)
break;
t -= get_time();
fftwf_execute(fwd);
t += get_time();
}
tavg = t/trial;
printf("FWD trials: %u, total time: %5g, avg time: %5g\n",trial,t,tavg);
fprintf(fp,"%g, ",tavg);
tfprev = tavg;
t = 0;
for (trial = 0; trial < MAX_TRIALS; trial++)
{
if (t > MAX_TIME)
break;
t -= get_time();
fftwf_execute(bck);
t += get_time();
}
tavg = t/trial;
printf("BCK trials: %u, total time: %5g, avg time: %5g\n",trial,t,tavg);
fprintf(fp,"%g, ",tavg);
tbprev = tavg;
fftwf_destroy_plan(fwd);
fftwf_destroy_plan(bck);
//MEASURE --------------- ---------------
temp = (float)get_time();
for (int i = 0; i < nfft[i]; i++)
a[i] = temp;
bptr = (float*)b;
for (int i = 0; i < 2*cfft[i]; i++)
bptr[i] = temp;
printf("MEASURE: \n");
fwd = fftwf_plan_dft_r2c_1d(nfft[l],a,b,FFTW_MEASURE);
bck = fftwf_plan_dft_c2r_1d(nfft[l],b,a,FFTW_MEASURE);
t = 0;
for (trial = 0; trial < MAX_TRIALS; trial++)
{
if (t > MAX_TIME)
break;
t -= get_time();
fftwf_execute(fwd);
t += get_time();
}
tavg = t/trial;
printf("FWD trials: %u, total time: %5g, avg time: %5g (%5g,%5g)\n",trial,t,tavg,100*tavg/tfprev,100*tfprev/tavg);
fprintf(fp,"%g, ",tavg);
tfprev = tavg;
t = 0;
for (trial = 0; trial < MAX_TRIALS; trial++)
{
if (t > MAX_TIME)
break;
t -= get_time();
fftwf_execute(bck);
t += get_time();
}
tavg = t/trial;
printf("BCK trials: %u, total time: %5g, avg time: %5g (%5g,%5g)\n",trial,t,tavg,100*tavg/tbprev,100*tbprev/tavg);
fprintf(fp,"%g, ",tavg);
tbprev = tavg;
fftwf_destroy_plan(fwd);
fftwf_destroy_plan(bck);
//PATIENT --------------- ---------------
temp = (float)get_time();
for (int i = 0; i < nfft[i]; i++)
a[i] = temp;
bptr = (float*)b;
for (int i = 0; i < 2*cfft[i]; i++)
bptr[i] = temp;
printf("PATIENT: \n");
fwd = fftwf_plan_dft_r2c_1d(nfft[l],a,b,FFTW_PATIENT);
bck = fftwf_plan_dft_c2r_1d(nfft[l],b,a,FFTW_PATIENT);
t = 0;
for (trial = 0; trial < MAX_TRIALS; trial++)
{
if (t > MAX_TIME)
break;
t -= get_time();
fftwf_execute(fwd);
t += get_time();
}
tavg = t/trial;
printf("FWD trials: %u, total time: %5g, avg time: %5g (%5g,%5g)\n",trial,t,tavg,100*tavg/tfprev,100*tfprev/tavg);
fprintf(fp,"%g, ",tavg);
t = 0;
for (trial = 0; trial < MAX_TRIALS; trial++)
{
if (t > MAX_TIME)
break;
t -= get_time();
fftwf_execute(bck);
t += get_time();
}
tavg = t/trial;
printf("BCK trials: %u, total time: %5g, avg time: %5g (%5g,%5g)\n",trial,t,tavg,100*tavg/tbprev,100*tbprev/tavg);
fprintf(fp,"%g\n",tavg);
fftwf_destroy_plan(fwd);
fftwf_destroy_plan(bck);
delete[] a;
fftwf_free(b);
}
if (FILE* wisdomfile = fopen("wisdom.wis","w"))
{
fftwf_export_wisdom_to_file(wisdomfile);
fclose(wisdomfile);
}
fclose(fp);
return 0;
}
void hcInitSingle(HConvSingle *filter, float *h, int hlen, int flen, int steps)
{
int i, j, size, num, pos;
float gain;
// processing step counter
filter->step = 0;
// number of processing steps per audio frame
filter->maxstep = steps;
// current frame index
filter->mixpos = 0;
// number of samples per audio frame
filter->framelength = flen;
// DFT buffer (time domain)
size = sizeof(float) * 2 * flen;
filter->dft_time = (float *)fftwf_malloc(size);
// DFT buffer (frequency domain)
size = sizeof(fftwf_complex) * (flen + 1);
filter->dft_freq = (fftwf_complex*)fftwf_malloc(size);
// input buffer (frequency domain)
size = sizeof(float) * (flen + 1);
filter->in_freq_real = (float*)fftwf_malloc(size);
filter->in_freq_imag = (float*)fftwf_malloc(size);
// number of filter segments
filter->num_filterbuf = (hlen + flen - 1) / flen;
// processing tasks per step
size = sizeof(int) * (steps + 1);
filter->steptask = (int *)malloc(size);
num = filter->num_filterbuf / steps;
for (i = 0; i <= steps; i++)
filter->steptask[i] = i * num;
if (filter->steptask[1] == 0)
pos = 1;
else
pos = 2;
num = filter->num_filterbuf % steps;
for (j = pos; j < pos + num; j++)
{
for (i = j; i <= steps; i++)
filter->steptask[i]++;
}
// filter segments (frequency domain)
size = sizeof(float*) * filter->num_filterbuf;
filter->filterbuf_freq_real = (float**)fftwf_malloc(size);
filter->filterbuf_freq_imag = (float**)fftwf_malloc(size);
for (i = 0; i < filter->num_filterbuf; i++)
{
size = sizeof(float) * (flen + 1);
filter->filterbuf_freq_real[i] = (float*)fftwf_malloc(size);
filter->filterbuf_freq_imag[i] = (float*)fftwf_malloc(size);
}
// number of mixing segments
filter->num_mixbuf = filter->num_filterbuf + 1;
// mixing segments (frequency domain)
size = sizeof(float*) * filter->num_mixbuf;
filter->mixbuf_freq_real = (float**)fftwf_malloc(size);
filter->mixbuf_freq_imag = (float**)fftwf_malloc(size);
for (i = 0; i < filter->num_mixbuf; i++)
{
size = sizeof(float) * (flen + 1);
filter->mixbuf_freq_real[i] = (float*)fftwf_malloc(size);
filter->mixbuf_freq_imag[i] = (float*)fftwf_malloc(size);
memset(filter->mixbuf_freq_real[i], 0, size);
memset(filter->mixbuf_freq_imag[i], 0, size);
}
// history buffer (time domain)
size = sizeof(float) * flen;
filter->history_time = (float *)fftwf_malloc(size);
memset(filter->history_time, 0, size);
// FFT transformation plan
filter->fft = fftwf_plan_dft_r2c_1d(2 * flen, filter->dft_time, filter->dft_freq, FFTW_ESTIMATE|FFTW_PRESERVE_INPUT);
// IFFT transformation plan
filter->ifft = fftwf_plan_dft_c2r_1d(2 * flen, filter->dft_freq, filter->dft_time, FFTW_ESTIMATE|FFTW_PRESERVE_INPUT);
// generate filter segments
gain = 0.5f / flen;
size = sizeof(float) * 2 * flen;
memset(filter->dft_time, 0, size);
for (i = 0; i < filter->num_filterbuf - 1; i++)
{
for (j = 0; j < flen; j++)
filter->dft_time[j] = gain * h[i * flen + j];
fftwf_execute(filter->fft);
for (j = 0; j < flen + 1; j++)
{
filter->filterbuf_freq_real[i][j] = filter->dft_freq[j][0];
filter->filterbuf_freq_imag[i][j] = filter->dft_freq[j][1];
}
}
for (j = 0; j < hlen - i * flen; j++)
filter->dft_time[j] = gain * h[i * flen + j];
size = sizeof(float) * ((i + 1) * flen - hlen);
memset(&(filter->dft_time[hlen - i * flen]), 0, size);
fftwf_execute(filter->fft);
for (j = 0; j < flen + 1; j++)
{
filter->filterbuf_freq_real[i][j] = filter->dft_freq[j][0];
filter->filterbuf_freq_imag[i][j] = filter->dft_freq[j][1];
}
}
int main()
{
unsigned overlap = (fftlen - chunklen) / 2;
// Create data
float *input = (float *) malloc(nsamp * ndms * sizeof(float));
// LOAD FILE: FOR TESTING ONLY
// FILE *fp = fopen("/home/lessju/Code/MDSM/src/prototypes/TestingCCode.dat", "rb");
// printf("Read: %ld\n", fread(input, sizeof(float), nsamp, fp));
// fclose(fp);
// Initialise templating
unsigned numDownFacts;
for(numDownFacts = 0; numDownFacts < 12; numDownFacts++)
if (downfactors[numDownFacts] > maxDownfact)
break;
// Allocate kernels
fftwf_complex **kernels = (fftwf_complex **) malloc(numDownFacts * sizeof(fftwf_complex *));
for(unsigned i = 0; i < numDownFacts; i++)
kernels[i] = (fftwf_complex *) fftwf_malloc(fftlen / 2 * sizeof(fftwf_complex));
// Create kernels
for(unsigned i = 0; i < numDownFacts; i++)
createFFTKernel(kernels[i], downfactors[i], fftlen);
// Start timing
struct timeval start, end;
long mtime, seconds, useconds;
gettimeofday(&start, NULL);
// Set number of OpenMP threads
omp_set_num_threads(threads);
// Create candidate container
std::vector<Candidate> **candidates = (std::vector<Candidate> **) malloc(threads * sizeof(std::vector<Candidate> *));
unsigned nchunks = nsamp / chunklen;
#pragma omp parallel \
shared(kernels, input, ndms, nsamp, fftlen, chunklen, numDownFacts, tsamp, \
overlap, downfactors, threshold, nchunks, candidates)
{
// Get thread details
unsigned numThreads = omp_get_num_threads();
unsigned threadId = omp_get_thread_num();
// Allocate memory to be used in processing
candidates[threadId] = new std::vector<Candidate>();
float *chunk = (float *) fftwf_malloc(fftlen * sizeof(float)); // Store input chunk
fftwf_complex *fftChunk = (fftwf_complex *)
fftwf_malloc(fftlen / 2 * sizeof(fftwf_complex)); // Store FFT'ed input chunk
fftwf_complex *convolvedChunk = (fftwf_complex *)
fftwf_malloc(fftlen / 2 * sizeof(fftwf_complex)); // Store FFT'ed, convolved input chunk
InitialCandidate *initialCands = (InitialCandidate *)
malloc(fftlen * sizeof(InitialCandidate)); // Store initial Candidate list
// Create FFTW plans (these calls are note thread safe, place in critical section)
fftwf_plan chunkPlan, convPlan;
#pragma omp critical
{
chunkPlan = fftwf_plan_dft_r2c_1d(fftlen, chunk, fftChunk, FFTW_ESTIMATE);
convPlan = fftwf_plan_dft_c2r_1d(fftlen, convolvedChunk, chunk, FFTW_ESTIMATE) ;
}
// Process all DM buffer associated with this thread
for(unsigned j = 0; j < ndms / numThreads; j++)
{
unsigned d = ndms / numThreads * threadId + j;
std::vector<Candidate> dmCandidates;
// Process all data chunks
for (unsigned c = 0; c < nchunks; c++)
{
int beg = d * nsamp + c * chunklen - overlap;
if (c == 0) // First chunk, we need to insert 0s at the beginning
{
memset(chunk, 0, overlap * sizeof(float));
memcpy(chunk + overlap, input, (fftlen - overlap) * sizeof(float));
}
else if (c == nchunks - 1) // Last chunk, insert 0s at the end
{
memset(chunk + fftlen - overlap, 0, overlap * sizeof(float));
memcpy(chunk, input + beg, (fftlen - overlap) * sizeof(float));
}
else
memcpy(chunk, input + beg, fftlen * sizeof(float));
// Search non-downsampled data first
for(unsigned i = overlap; i < chunklen; i++)
if (chunk[i] >= threshold)
{
candidate newCand = { d, chunk[i], 25, c*chunklen+i, 1 };
dmCandidates.push_back(newCand);
}
// FFT current chunk
fftwf_execute(chunkPlan);
// Loop over all downfactor levels
for(unsigned s = 0; s < numDownFacts; s++)
{
// Reset inital Candidate List
memset(initialCands, 0, fftlen * sizeof(InitialCandidate));
// Perform convolution
convolve(fftChunk, kernels[s], convolvedChunk, chunk, fftlen, convPlan);
// Threshold results and build preliminary candidate list
unsigned numCands = 0;
for(unsigned i = overlap; i < chunklen; i++)
{
if (chunk[i] >= threshold)
{
// printf("We have something %d %d \n", c, s);
initialCands[numCands].bin = i;
initialCands[numCands].value = chunk[i];
numCands++;
}
}
if (numCands != 0)
{
// Prune candidate list
pruneRelated(initialCands, downfactors[s], numCands);
// Store candidate list
for(unsigned k = 0; k < numCands; k++)
if (initialCands[k].value != 0)
{
Candidate newCand = { d, initialCands[j].value, 5, c * chunklen + k, downfactors[s] };
dmCandidates.push_back(newCand);
}
}
}
}
// Remove redundate candidates across downsampling levels
if (dmCandidates.size() > 0)
{
char *mask = (char *) malloc(dmCandidates.size() * sizeof(char));
pruneRelatedDownfactors(dmCandidates, mask, numDownFacts);
// Append to final candidate list
for(j = 0; j < dmCandidates.size(); j++)
if (mask[j])
candidates[threadId] -> push_back(dmCandidates[j]);
free(mask);
}
}
free(convolvedChunk);
free(fftChunk);
free(chunk);
}
gettimeofday(&end, NULL);
seconds = end.tv_sec - start.tv_sec;
useconds = end.tv_usec - start.tv_usec;
mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;
printf("Processed everything in %ld ms\n", mtime);
// Now write everything to disk...
FILE *fp2 = fopen("output.dat", "w");
for(unsigned i = 0; i < threads; i++)
for(unsigned j = 0; j < candidates[i] -> size(); j++)
{
Candidate cand = candidates[i] -> at(j);
fprintf(fp2, "%f,%f,%f,%ld,%d\n", cand.dm, cand.value, cand.time, cand.bin, cand.downfact);
}
fflush(fp2);
fclose(fp2);
}
void benchmark_ffts(int N, int cplx) {
int Nfloat = (cplx ? N*2 : N);
int Nbytes = Nfloat * sizeof(float);
float *X = pffft_aligned_malloc(Nbytes), *Y = pffft_aligned_malloc(Nbytes), *Z = pffft_aligned_malloc(Nbytes);
double t0, t1, flops;
int k;
int max_iter = 5120000/N*4;
#ifdef __arm__
max_iter /= 4;
#endif
int iter;
for (k = 0; k < Nfloat; ++k) {
X[k] = 0; //sqrtf(k+1);
}
// FFTPack benchmark
{
float *wrk = malloc(2*Nbytes + 15*sizeof(float));
int max_iter_ = max_iter/pffft_simd_size(); if (max_iter_ == 0) max_iter_ = 1;
if (cplx) cffti(N, wrk);
else rffti(N, wrk);
t0 = uclock_sec();
for (iter = 0; iter < max_iter_; ++iter) {
if (cplx) {
cfftf(N, X, wrk);
cfftb(N, X, wrk);
} else {
rfftf(N, X, wrk);
rfftb(N, X, wrk);
}
}
t1 = uclock_sec();
free(wrk);
flops = (max_iter_*2) * ((cplx ? 5 : 2.5)*N*log((double)N)/M_LN2); // see http://www.fftw.org/speed/method.html
show_output("FFTPack", N, cplx, flops, t0, t1, max_iter_);
}
#ifdef HAVE_VECLIB
int log2N = (int)(log(N)/log(2) + 0.5f);
if (N == (1<<log2N)) {
FFTSetup setup;
setup = vDSP_create_fftsetup(log2N, FFT_RADIX2);
DSPSplitComplex zsamples;
zsamples.realp = &X[0];
zsamples.imagp = &X[Nfloat/2];
t0 = uclock_sec();
for (iter = 0; iter < max_iter; ++iter) {
if (cplx) {
vDSP_fft_zip(setup, &zsamples, 1, log2N, kFFTDirection_Forward);
vDSP_fft_zip(setup, &zsamples, 1, log2N, kFFTDirection_Inverse);
} else {
vDSP_fft_zrip(setup, &zsamples, 1, log2N, kFFTDirection_Forward);
vDSP_fft_zrip(setup, &zsamples, 1, log2N, kFFTDirection_Inverse);
}
}
t1 = uclock_sec();
vDSP_destroy_fftsetup(setup);
flops = (max_iter*2) * ((cplx ? 5 : 2.5)*N*log((double)N)/M_LN2); // see http://www.fftw.org/speed/method.html
show_output("vDSP", N, cplx, flops, t0, t1, max_iter);
} else {
show_output("vDSP", N, cplx, -1, -1, -1, -1);
}
#endif
#ifdef HAVE_FFTW
{
fftwf_plan planf, planb;
fftw_complex *in = (fftw_complex*) fftwf_malloc(sizeof(fftw_complex) * N);
fftw_complex *out = (fftw_complex*) fftwf_malloc(sizeof(fftw_complex) * N);
memset(in, 0, sizeof(fftw_complex) * N);
int flags = (N < 40000 ? FFTW_MEASURE : FFTW_ESTIMATE); // measure takes a lot of time on largest ffts
//int flags = FFTW_ESTIMATE;
if (cplx) {
planf = fftwf_plan_dft_1d(N, (fftwf_complex*)in, (fftwf_complex*)out, FFTW_FORWARD, flags);
planb = fftwf_plan_dft_1d(N, (fftwf_complex*)in, (fftwf_complex*)out, FFTW_BACKWARD, flags);
} else {
planf = fftwf_plan_dft_r2c_1d(N, (float*)in, (fftwf_complex*)out, flags);
planb = fftwf_plan_dft_c2r_1d(N, (fftwf_complex*)in, (float*)out, flags);
}
t0 = uclock_sec();
for (iter = 0; iter < max_iter; ++iter) {
fftwf_execute(planf);
fftwf_execute(planb);
}
t1 = uclock_sec();
fftwf_destroy_plan(planf);
fftwf_destroy_plan(planb);
fftwf_free(in); fftwf_free(out);
flops = (max_iter*2) * ((cplx ? 5 : 2.5)*N*log((double)N)/M_LN2); // see http://www.fftw.org/speed/method.html
show_output((flags == FFTW_MEASURE ? "FFTW (meas.)" : " FFTW (estim)"), N, cplx, flops, t0, t1, max_iter);
}
#endif
// PFFFT benchmark
{
PFFFT_Setup *s = pffft_new_setup(N, cplx ? PFFFT_COMPLEX : PFFFT_REAL);
if (s) {
t0 = uclock_sec();
for (iter = 0; iter < max_iter; ++iter) {
pffft_transform(s, X, Z, Y, PFFFT_FORWARD);
pffft_transform(s, X, Z, Y, PFFFT_BACKWARD);
}
t1 = uclock_sec();
pffft_destroy_setup(s);
flops = (max_iter*2) * ((cplx ? 5 : 2.5)*N*log((double)N)/M_LN2); // see http://www.fftw.org/speed/method.html
show_output("PFFFT", N, cplx, flops, t0, t1, max_iter);
}
}
if (!array_output_format) {
printf("--\n");
}
pffft_aligned_free(X);
pffft_aligned_free(Y);
pffft_aligned_free(Z);
}
int main(int argc, char* argv[])
{
map4 str;
bool verb;
int i1,i2, n1,n2,n3, nw, nx,ny,nv, ix,iy,iv;
float d1,o1,d2,o2, eps, w,x,y, v0,v2,v,dv, dx,dy, t, x0,y0, dw;
float *trace, *strace, *t2;
sf_complex *ctrace, *ctrace2, shift;
sf_file in, out;
#ifdef SF_HAS_FFTW
fftwf_plan forw, invs;
#else
kiss_fftr_cfg forw, invs;
#endif
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&ny)) sf_error("No n3= in input");
if (!sf_getfloat("eps",&eps)) eps=0.01; /* regularization */
if (!sf_getint("pad",&n2)) n2=n1; /* padding for stretch */
if (!sf_getint("pad2",&n3)) n3=2*kiss_fft_next_fast_size((n2+1)/2);
/* padding for FFT */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
nw = n3/2+1;
strace = sf_floatalloc(n3);
ctrace = sf_complexalloc(nw);
ctrace2 = sf_complexalloc(nw);
#ifdef SF_HAS_FFTW
forw = fftwf_plan_dft_r2c_1d(n3, strace, (fftwf_complex *) ctrace,
FFTW_ESTIMATE);
invs = fftwf_plan_dft_c2r_1d(n3, (fftwf_complex *) ctrace2, strace,
FFTW_ESTIMATE);
#else
forw = kiss_fftr_alloc(n3,0,NULL,NULL);
invs = kiss_fftr_alloc(n3,1,NULL,NULL);
#endif
if (NULL == forw || NULL == invs) sf_error("FFT allocation error");
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
o2 = o1*o1;
if(!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
d2 = o1+(n1-1)*d1;
d2 = (d2*d2 - o2)/(n2-1);
dw = 16*SF_PI/(d2*n3); /* 2pi * 8 */
if (!sf_getint("nv",&nv)) sf_error("Need nv=");
/* velocity steps */
if (!sf_getfloat("dv",&dv)) sf_error("Need dv=");
/* velocity step size */
if (!sf_getfloat("v0",&v0) &&
!sf_histfloat(in,"v0",&v0)) sf_error("Need v0=");
/*( v0 starting velocity )*/
if(!sf_histfloat(in,"d2",&dx)) sf_error("No d2= in input");
if(!sf_histfloat(in,"o2",&x0)) x0=0.;
if(!sf_histfloat(in,"d3",&dy)) sf_error("No d3= in input");
if(!sf_histfloat(in,"o3",&y0)) y0=0.;
sf_putfloat(out,"o2",v0+dv);
sf_putfloat(out,"d2",dv);
sf_putint(out,"n2",nv);
sf_putstring(out,"label2","Velocity");
sf_shiftdim(in, out, 2);
dx *= 2.*SF_PI;
x0 *= 2.*SF_PI;
dy *= 2.*SF_PI;
y0 *= 2.*SF_PI;
trace = sf_floatalloc(n1);
t2 = sf_floatalloc(n2);
str = stretch4_init (n1, o1, d1, n2, eps);
for (i2=0; i2 < n2; i2++) {
t = o2+i2*d2;
t2[i2] = sqrtf(t);
}
stretch4_define (str,t2);
for (iy=0; iy < ny; iy++) {
if (verb) sf_warning("wavenumber %d of %d;", iy+1,ny);
y = y0+iy*dy;
y *= y * 0.5;
for (ix=0; ix < nx; ix++) {
x = x0+ix*dx;
x *= x * 0.5;
x += y;
sf_floatread(trace,n1,in);
for (i1=0; i1 < n1; i1++) {
trace[i1] /= n1;
}
stretch4_invert (false,str,strace,trace);
for (i2=n2; i2 < n3; i2++) {
strace[i2] = 0.;
}
#ifdef SF_HAS_FFTW
fftwf_execute(forw);
#else
kiss_fftr(forw,strace, (kiss_fft_cpx *) ctrace);
#endif
for (iv=0; iv < nv; iv++) {
v = v0 + (iv+1)*dv;
v2 = x * ((v0*v0) - (v*v));
ctrace2[0] = sf_cmplx(0.0f,0.0f); /* dc */
for (i2=1; i2 < nw; i2++) {
w = i2*dw;
w = v2/w;
shift = sf_cmplx(cosf(w),sinf(w));
#ifdef SF_HAS_COMPLEX_H
ctrace2[i2] = ctrace[i2] * shift;
#else
ctrace2[i2] = sf_cmul(ctrace[i2],shift);
#endif
} /* w */
#ifdef SF_HAS_FFTW
fftwf_execute(invs);
#else
kiss_fftri(invs,(const kiss_fft_cpx *) ctrace2, strace);
#endif
stretch4_apply(false,str,strace,trace);
sf_floatwrite (trace,n1,out);
} /* v */
} /* x */
} /* y */
if (verb) sf_warning(".");
exit (0);
}
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];
}
}
}
}
void populateRedNoiseModel(rednoisemodel_t* model,long seed){
int t_npts;
int i;
double freq,A,index;
double t_samp,f_bin,t_span;
float *data;
fftwf_plan plan;
fftwf_complex *spectrum;
double secperyear=365*86400.0;
t_samp=(model->end - model->start)/(float)model->npt;
model->start-=t_samp;
model->end+=t_samp*2.0;
if (seed == 0){
seed=TKsetSeed();
}else if (seed > 0){
seed=-seed;
}
t_npts=model->npt*model->nreal;
spectrum = (fftwf_complex*) fftwf_malloc((t_npts/2+1)*sizeof(fftwf_complex));
data = (float*) fftwf_malloc(t_npts*sizeof(float));
t_span=(model->end - model->start)/365.25; // years
t_samp=t_span/(float)model->npt;
model->tres=t_samp*365.25;
f_bin=1.0/(t_span*model->nreal); // frequency in yr^-1
// To convert PSD to FFT power, need to multiply by N^2/T.
// BUT FFTW does not divide by N^2 on inverse transform
// so we need to divide by N^2.
// The factor of 4, converts one-sided P to 2-sided P as
// we input one-sided, and FFTW expected 2-sided.
//
// I am now 99% sure this is correct. George looked at it too!
// M. Keith 2013.
A=model->pwr_1yr /(4*t_span*model->nreal);
// we are forming "amplitudes" not powers
// so square root.
index=model->index/2.0;
A = sqrt(A);
// form a complex spectrum, then do a c2r transform.
spectrum[0]=0;
for (i=1; i < t_npts/2+1; i++){
freq=(double)i*f_bin;
double scale=0;
if(model->mode==MODE_T2CHOL){
// same definition as the Cholesky code (except index is negative)
scale=A*pow(1.0+pow(fabs(freq)/model->flatten,2),index/2.0);
}
if(model->mode==MODE_SIMPLE){
if (freq < model->flatten)
freq=model->flatten;
scale = A*pow(freq,index);
if (freq < model->cutoff)scale=0;
}
// complex spectrum
spectrum[i]=(scale*TKgaussDev(&seed) + I*scale*TKgaussDev(&seed));
}
plan=fftwf_plan_dft_c2r_1d(t_npts,spectrum,data,FFTW_ESTIMATE);
fftwf_execute(plan);
fftwf_destroy_plan(plan);
fftwf_free(spectrum);
model->data=data;
}
