SpectrometryTask::SpectrometryTask(string name_) : QTask(name_, SPECTROMETRY_PRIO), activity(0), CTBufsFilled(0), CTBufsEmptied(0), initWave(false) { float twopi, w; twopi = 8.0 * atan(1.0); ObsData obsData; #ifdef DO_TIMING_TESTS tvE.tv_usec = 0; tvL.tv_usec = 0; #endif // allocate the frame array int32_t size = FRAME_SAMPLES * sizeof(complexFloat); Frame = static_cast<complexFloat *> (fftwf_malloc(size)); if (!initWave) { /* initialize the fake signal array */ for (int i=0; i<FRAME_SAMPLES; i++) { w = (i+0.5)/FRAME_SAMPLES * twopi; Wave[i] = sinf(w); } initWave = true; // create the fftw plans plan1024 = fftwf_plan_dft_1d(FRAME_SAMPLES, (fftwf_complex *) Frame, (fftwf_complex *) Frame, FFTW_FORWARD, FFTW_MEASURE); plan512 = fftwf_plan_dft_1d(FRAME_SAMPLES / 2, (fftwf_complex *) Frame, (fftwf_complex *) Frame, FFTW_FORWARD, FFTW_MEASURE); } }
void four1(float data[], unsigned long nn, int isign) { int n = nn; if (n != n_prev) { /* Create plans */ if (n_prev != 0) fftwf_free(in_1d); in_1d = fftwf_malloc(sizeof(fftwf_complex)*n); out_1d = in_1d; printf("fft_test1f: creating plans, n=%d, n_prev=%d\n", n, n_prev); n_prev = n; forward_plan_1d = fftwf_plan_dft_1d(n, in_1d, out_1d, FFTW_FORWARD, FFTW_MEASURE); backward_plan_1d = fftwf_plan_dft_1d(n, in_1d, out_1d, FFTW_BACKWARD, FFTW_MEASURE); } /* The Numerical Recipes routines are passed a pointer to one element * before the start of the array - add one */ memcpy(in_1d, data+1, n*sizeof(fftwf_complex)); if (isign == -1) fftwf_execute(forward_plan_1d); else fftwf_execute(backward_plan_1d); memcpy(data+1, out_1d, n*sizeof(fftwf_complex)); }
/* LEX correlation function ---------------------------------------------------- * compute LEX message based on FFT * args : sdrch_t *sdr I sdr channel struct * char *data I input 4ms IF data * int dtype I sampling data type (1:real,2:complex) * double ti I sampling interval (s) * int n I number of samples * double freq I doppler frequency computed by L1 signal (Hz) * double crate I code chip rate (chip/s) * int m I number of FFT points * cpx_t codex I frequency domain code * double *cn O estimated C/N0 * return : uint8_t LEX message word * note : LEX message uses CSK modulation and it can be solve by FFT correlation * LEX(E6) doppler shift and code phase are estimated by L1 signal *-----------------------------------------------------------------------------*/ uint8_t lexcorr_fft(sdrch_t *sdr, const char *data, int dtype, double ti, int n, double freq, double crate, int m, cpx_t* codex, double *cn) { int codei,codei2,corri,exinds,exinde; cpx_t *datax; short *dataI,*dataQ; char *dataR; double peakr,*P,maxP,maxP2,meanP; /* memory allocation */ if (!(P=(double*)calloc(m,sizeof(double))) || !(dataR=(char *)sdrmalloc(sizeof(char )*m*dtype))|| !(dataI=(short *)sdrmalloc(sizeof(short)*m))|| !(dataQ=(short *)sdrmalloc(sizeof(short)*m))|| !(datax=cpxmalloc(m))) return -1; /* zero padding */ memset(dataR,0,m*dtype); memcpy(dataR,data,n*dtype); /* mix local carrier */ mixcarr(dataR,dtype,ti,m,freq,0.0,dataI,dataQ); /* to complex */ cpxcpx(dataI,dataQ,(1.0/32)/m,m,datax); /* convolution */ if (plan==NULL||iplan==NULL) { fftwf_plan_with_nthreads(NFFTTHREAD); /* fft execute in multi threads */ plan=fftwf_plan_dft_1d(n,datax,datax,FFTW_FORWARD,FFTW_ESTIMATE); fftwf_plan_with_nthreads(NFFTTHREAD); /* fft execute in multi threads */ iplan=fftwf_plan_dft_1d(n,datax,datax,FFTW_BACKWARD,FFTW_ESTIMATE); } cpxconv(plan,iplan,datax,codex,m,m,0,P); /* maximum index */ maxP=maxvd(P,m,-1,-1,&codei); corri=(int)((double)(n-codei)/n*sdr->clen/2); if (corri==(int)(sdr->clen/2)) corri=0; /* C/N0 calculation */ exinds=codei-sdr->nsampchip; if(exinds<0) exinds+=n; /* excluded index */ exinde=codei+sdr->nsampchip; if(exinde>=n) exinde-=n; meanP=meanvd(P,n,exinds,exinde); /* mean of correlation */ (*cn)=10*log10(maxP/meanP/sdr->ctime); maxP2=maxvd(P,m,exinds,exinde,&codei2); peakr=maxP/maxP2; if (peakr<1.5) SDRPRINTF("error: peakr=%.1f\n",peakr); /* message must be 0-255 */ if (corri>255) SDRPRINTF("error: corri=%05d codei=%06d cn0=%.1f\n",corri,codei,cn); free(P); sdrfree(dataR); sdrfree(dataI); sdrfree(dataQ); cpxfree(datax); return (uint8_t)corri; }
epicsShareFunc void epicsShareAPI fftw_1d (float *argv1, int *argv2, int *argv3) { float *data = (float *)argv1; int n = *(int *)argv2; int isign = *(int *)argv3; static int n_prev; static fftwf_complex *in, *out; static fftwf_plan forward_plan, backward_plan; if (n != n_prev) { /* Create plans */ if (n_prev != 0) fftwf_free(in); in = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex)*n); out = in; //printf("fft_test1f: creating plans, n=%d, n_prev=%d\n", n, n_prev); n_prev = n; forward_plan = fftwf_plan_dft_1d(n, in, out, FFTW_FORWARD, FFTW_MEASURE); backward_plan = fftwf_plan_dft_1d(n, in, out, FFTW_BACKWARD, FFTW_MEASURE); } memcpy(in, data, n*sizeof(fftwf_complex)); if (isign == -1) fftwf_execute(forward_plan); else fftwf_execute(backward_plan); memcpy(data, in, n*sizeof(fftwf_complex)); }
Resampler::Resampler(size_t inputRate, size_t outputRate, size_t resolution) : ModCodec(ModFormat(inputRate * sizeof(complexf)), ModFormat(outputRate * sizeof(complexf))), myFftPlan1(NULL), myFftPlan2(NULL), myFftIn(NULL), myFftOut(NULL), myBufferIn(NULL), myBufferOut(NULL), myFront(NULL), myBack(NULL), myWindow(NULL) { PDEBUG("Resampler::Resampler(%zu, %zu) @ %p\n", inputRate, outputRate, this); size_t divisor = gcd(inputRate, outputRate); L = outputRate / divisor; M = inputRate / divisor; PDEBUG(" gcd: %zu, L: %zu, M: %zu\n", divisor, L, M); { size_t factor = resolution * 2 / M; if (factor & 1) { ++factor; } myFftSizeIn = factor * M; myFftSizeOut = factor * L; } PDEBUG(" FFT size in: %zu, FFT size out: %zu\n", myFftSizeIn, myFftSizeOut); if (myFftSizeIn > myFftSizeOut) { myFactor = 1.0f / myFftSizeIn; } else { myFactor = 1.0f / myFftSizeOut; } myWindow = (float*)memalign(16, myFftSizeIn * sizeof(float)); for (size_t i = 0; i < myFftSizeIn; ++i) { myWindow[i] = 0.5f * (1.0f - cosf(2.0f * M_PI * i / (myFftSizeIn - 1))); PDEBUG("Window[%zu] = %f\n", i, myWindow[i]); } myFftIn = (FFT_TYPE*)fftwf_malloc(sizeof(FFT_TYPE) * myFftSizeIn); myFront = (FFT_TYPE*)fftwf_malloc(sizeof(FFT_TYPE) * myFftSizeIn); myFftPlan1 = fftwf_plan_dft_1d(myFftSizeIn, myFftIn, myFront, FFTW_FORWARD, FFTW_MEASURE); myBack = (FFT_TYPE*)fftwf_malloc(sizeof(FFT_TYPE) * myFftSizeOut); myFftOut = (FFT_TYPE*)fftwf_malloc(sizeof(FFT_TYPE) * myFftSizeOut); myFftPlan2 = fftwf_plan_dft_1d(myFftSizeOut, myBack, myFftOut, FFTW_BACKWARD, FFTW_MEASURE); myBufferIn = (complexf*)fftwf_malloc(sizeof(FFT_TYPE) * myFftSizeIn / 2); myBufferOut = (complexf*)fftwf_malloc(sizeof(FFT_TYPE) * myFftSizeOut / 2); memset(myBufferIn, 0, myFftSizeIn / 2 * sizeof(FFT_TYPE)); memset(myBufferOut, 0, myFftSizeOut / 2 * sizeof(FFT_TYPE)); }
QFFT::QFFT(int size) : QObject() , m_size(size) , half_sz(size/2) { cpxbuf = (fftwf_complex *) fftwf_malloc(sizeof(fftwf_complex) * m_size); plan_fwd = fftwf_plan_dft_1d(m_size , cpxbuf, cpxbuf, FFTW_FORWARD, FFTW_MEASURE); plan_rev = fftwf_plan_dft_1d(m_size , cpxbuf, cpxbuf, FFTW_BACKWARD, FFTW_MEASURE); memset(cpxbuf, 0, m_size * sizeof(cpxbuf)); InitCPX(buf, m_size, 0.0f); }
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(); }
InputSource::InputSource(const char *filename, int fft_size) { m_fft_size = fft_size; m_file = fopen(filename, "rb"); if (m_file == nullptr) throw "Error opening file"; struct stat sb; if (fstat(fileno(m_file), &sb) != 0) throw "Error fstating file"; m_file_size = sb.st_size; m_data = (fftwf_complex*)mmap(NULL, m_file_size, PROT_READ, MAP_SHARED, fileno(m_file), 0); if (m_data == 0) throw "Error mmapping file"; m_fftw_in = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * m_fft_size); m_fftw_out = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * m_fft_size); m_fftw_plan = fftwf_plan_dft_1d(m_fft_size, m_fftw_in, m_fftw_out, FFTW_FORWARD, FFTW_MEASURE); m_window.reset(new float[m_fft_size]); for (int i = 0; i < m_fft_size; i++) { m_window[i] = 0.5f * (1.0f - cos(Tau * i / (m_fft_size - 1))); } m_zoom = 0; m_max_zoom = floor(log2(m_fft_size)); }
/* -------------------------------------------------------------------- * IFFT for floating complex number data * Comparation with Matlab Command : * b = ifft(A) --> b = ifftwf_data(A, lenA, lenA) * b = ifft(A, nfft) --> b = ifftwf_data(A, lenA, nfft) * -------------------------------------------------------------------- */ fftwf_complex *ifftwf_data(fftwf_complex *fdata, int ndata, int nfft) { fftwf_complex *idata; fftwf_complex *idatapad; fftwf_plan plan_backward; int i; if(nfft<ndata) { fprintf(stderr, "nfft < ndata \n"); exit(0); } //allocate memory for data idata = ( fftwf_complex* ) fftwf_malloc( sizeof( fftwf_complex ) * ndata ); //allocate memory for inversfft + padding idatapad = ( fftwf_complex* ) fftwf_malloc( sizeof( fftwf_complex ) * nfft ); plan_backward = fftwf_plan_dft_1d( nfft, fdata, idatapad, FFTW_BACKWARD, FFTW_ESTIMATE ); fftwf_execute( plan_backward ); //execute invers fft //get invers fft with length ndata and divide the value with nfft for( i=0; i<ndata; i++ ){ idata[i][0] = idatapad[i][0]/nfft; //real data idata[i][1] = idatapad[i][1]/nfft; //imaginer data } //free allocate memory fftwf_destroy_plan( plan_backward ); fftwf_free( idatapad ); return(idata); }
/* -------------------------------------------------------------------- * FFT for floating complex number data * Comparation with Matlab Command : * b = fft(A) --> b = fftwf_data(A, lenA, lenA) * b = fft(A, nfft) --> b = fftwf_data(A, lenA, nfft) * -------------------------------------------------------------------- */ fftwf_complex *fftwf_data(fftwf_complex *input, int ndata, int nfft) { fftwf_complex *paddata; fftwf_complex *fdata; fftwf_plan plan_forward; if(nfft<ndata) { fprintf(stderr, "nfft < ndata \n"); exit(0); } //allocate memory for data+padding paddata = ( fftwf_complex* ) fftwf_malloc( sizeof( fftwf_complex ) * nfft ); //allocate data for output fft process fdata = ( fftwf_complex* ) fftwf_malloc( sizeof( fftwf_complex ) * nfft ); //padding input data memset(paddata[0], 0, nfft*sizeof(fftwf_complex)); memcpy(paddata[0], input[0], ndata*sizeof(fftwf_complex)); plan_forward = fftwf_plan_dft_1d( nfft, paddata, fdata, FFTW_FORWARD, FFTW_ESTIMATE ); fftwf_execute( plan_forward ); //execute fft //free allocate memory fftwf_destroy_plan( plan_forward ); fftwf_free( paddata ); return(fdata); }
int srslte_dft_plan_c(srslte_dft_plan_t *plan, const int dft_points, srslte_dft_dir_t dir) { allocate(plan,sizeof(fftwf_complex),sizeof(fftwf_complex), dft_points); pthread_mutex_lock(&fft_mutex); int sign = (dir == SRSLTE_DFT_FORWARD) ? FFTW_FORWARD : FFTW_BACKWARD; plan->p = fftwf_plan_dft_1d(dft_points, plan->in, plan->out, sign, FFTW_TYPE); pthread_mutex_unlock(&fft_mutex); if (!plan->p) { return -1; } plan->size = dft_points; plan->init_size = plan->size; plan->mode = SRSLTE_DFT_COMPLEX; plan->dir = dir; plan->forward = (dir==SRSLTE_DFT_FORWARD)?true:false; plan->mirror = false; plan->db = false; plan->norm = false; plan->dc = false; plan->is_guru = false; return 0; }
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); }
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); }
BLMS new_blms (CXB signal, REAL adaptation_rate, REAL leak_rate, int filter_type, int pbits) { BLMS tmp; tmp = (BLMS) safealloc (1, sizeof (_blocklms), "block lms"); tmp->delay_line = newvec_COMPLEX (256, "block lms delay line"); tmp->y = newvec_COMPLEX (256, "block lms output signal"); tmp->Yhat = newvec_COMPLEX (256, "block lms output transform"); tmp->Errhat = newvec_COMPLEX (256, "block lms Error transform"); tmp->error = newvec_COMPLEX (256, "block lms Error signal"); tmp->Xhat = newvec_COMPLEX (256, "block lms signal transform"); tmp->What = newvec_COMPLEX (256, "block lms filter transform"); tmp->Update = newvec_COMPLEX (256, "block lms update transform"); tmp->update = newvec_COMPLEX (256, "block lms update signal"); tmp->adaptation_rate = adaptation_rate; tmp->leak_rate = 1.0f - leak_rate; tmp->signal = signal; tmp->filter_type = filter_type; tmp->Xplan = fftwf_plan_dft_1d (256, (fftwf_complex *) tmp->delay_line, (fftwf_complex *) tmp->Xhat, FFTW_FORWARD, pbits); tmp->Yplan = fftwf_plan_dft_1d (256, (fftwf_complex *) tmp->Yhat, (fftwf_complex *) tmp->y, FFTW_BACKWARD, pbits); tmp->Errhatplan = fftwf_plan_dft_1d (256, (fftwf_complex *) tmp->error, (fftwf_complex *) tmp->Errhat, FFTW_FORWARD, pbits); tmp->UPDplan = fftwf_plan_dft_1d (256, (fftwf_complex *) tmp->Errhat, (fftwf_complex *) tmp->update, FFTW_BACKWARD, pbits); tmp->Wplan = fftwf_plan_dft_1d (256, (fftwf_complex *) tmp->update, (fftwf_complex *) tmp->Update, FFTW_FORWARD, pbits); return tmp; }
int sq_fft(FILE* instream, FILE* outstream, unsigned int fft_len, unsigned char is_inverted, unsigned char is_measured, unsigned char inverse) { if (fft_len <= 0) return ERR_ARG_BOUNDS; fftwf_complex *fft_bfr; fftwf_plan plan; int i; fft_bfr = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * fft_len); plan = fftwf_plan_dft_1d(fft_len, (fft_bfr), (fft_bfr), (inverse ? FFTW_BACKWARD : FFTW_FORWARD), (is_measured ? FFTW_MEASURE : FFTW_ESTIMATE)); while (fread(fft_bfr, sizeof(fftwf_complex), fft_len, instream) == fft_len) { if (is_inverted) for (i = 0; i < fft_len; i++) fft_bfr[i][1] = -fft_bfr[i][1]; // conjugate if(inverse) { // move channels back to their original positions before the fft, so that ifft gets what it expects sq_channelswap(fft_bfr, fft_len); // perform ifft fftwf_execute(plan); for(i = 0; i < fft_len; i++) { fft_bfr[i][0] = fft_bfr[i][0] / fft_len; fft_bfr[i][1] = fft_bfr[i][1] / fft_len; } } else { // perform fft fftwf_execute(plan); // write negative channels on the left, and then positive channels on the right sq_channelswap(fft_bfr, fft_len); } fwrite(&fft_bfr[0], sizeof(fftwf_complex), fft_len , outstream); } fftwf_destroy_plan(plan); fftwf_free(fft_bfr); return 0; }
VCRDecoder() { FileStream inputStream = File("U:\\c2.raw", true).openRead(); //FileStream inputStream = File("U:\\captured.bin", true).openRead(); int nn = inputStream.size(); FileStream h = File("U:\\vcr_decoded.bin", true).openWrite(); int samplesPerFrame = 1824*253; Array<Byte> input(samplesPerFrame); _fftData.allocate(2048); _chromaData.allocate(2048); _burstData.allocate(91); _forward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_fftData[0]), reinterpret_cast<fftwf_complex*>(&_fftData[0]), -1, FFTW_MEASURE); _backward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_fftData[0]), reinterpret_cast<fftwf_complex*>(&_fftData[0]), 1, FFTW_MEASURE); _chromaForward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_chromaData[0]), reinterpret_cast<fftwf_complex*>(&_chromaData[0]), -1, FFTW_MEASURE); _chromaBackward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_chromaData[0]), reinterpret_cast<fftwf_complex*>(&_chromaData[0]), 1, FFTW_MEASURE); Complex<float> localOscillatorFrequency = unit(4.4f*11/315); Complex<float> chromaOscillatorFrequency = unit(2.0f/91); // 0.629 == 315/11 / 2 / 4 * 16 / 91 0.629f*11/315 == 16/8/91 //static const float cutoff = 3.0f*2048*11/315; // 3.3f //static const int cutoff = 208; static const int cutoff = static_cast<int>(2.2f*2048*11/315); static const int chromaCutoff = static_cast<int>(2048.0*2.0/91)*0.75; // *0.5; _outputb0.allocate(2048); _outputb1.allocate(2048); Array<Complex<float>> amplitudes(253); for (int y = 0; y < 253; ++y) amplitudes[y] = 0; Array<Vector3<float>> frameCache(3*2048*253); for (int i = 0; i < 3*2048*253; ++i) frameCache[i] = Vector3<float>(0, 0, 0); int frame = 0; Complex<float> burstAcc = 0; Complex<float> framePhase = unit((90 - 33)/360.0f); }
int srslte_dft_replan_c(srslte_dft_plan_t *plan, const int new_dft_points) { int sign = (plan->dir == SRSLTE_DFT_FORWARD) ? FFTW_FORWARD : FFTW_BACKWARD; if (plan->p) { fftwf_destroy_plan(plan->p); plan->p = NULL; } plan->p = fftwf_plan_dft_1d(new_dft_points, plan->in, plan->out, sign, FFTW_TYPE); if (!plan->p) { return -1; } plan->size = new_dft_points; return 0; }
/* complex IFFT ---------------------------------------------------------------- * cpx=ifft(cpx) * args : fftwf_plan plan I fftw plan (NULL: create new plan) * cpx_t *cpx I/O input/output complex data * int n I number of input/output data * return : none *-----------------------------------------------------------------------------*/ extern void cpxifft(fftwf_plan plan, cpx_t *cpx, int n) { if (plan==NULL) { mlock(hfftmtx); fftwf_plan_with_nthreads(NFFTTHREAD); /* fft execute in multi threads */ plan=fftwf_plan_dft_1d(n,cpx,cpx,FFTW_BACKWARD,FFTW_ESTIMATE); fftwf_execute_dft(plan,cpx,cpx); /* fft */ fftwf_destroy_plan(plan); unmlock(hfftmtx); } else { fftwf_execute_dft(plan,cpx,cpx); /* fft */ } }
float* fftcv_mults (int NM, float* c_impulse) { float* mults = (float *) malloc0 (NM * sizeof (complex)); float* cfft_impulse = (float *) malloc0 (NM * sizeof (complex)); fftwf_plan ptmp = fftwf_plan_dft_1d(NM, (fftwf_complex *) cfft_impulse, (fftwf_complex *) mults, FFTW_FORWARD, FFTW_PATIENT); memset (cfft_impulse, 0, NM * sizeof (complex)); // store complex coefs right-justified in the buffer memcpy (&(cfft_impulse[NM - 2]), c_impulse, (NM / 2 + 1) * sizeof(complex)); fftwf_execute (ptmp); fftwf_destroy_plan (ptmp); _aligned_free (cfft_impulse); return mults; }
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; }
static void fftw_init(struct fftw_state *state, const int logN) { const int N = 1 << logN; int i; state->in = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * N); state->out = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * N); state->p = fftwf_plan_dft_1d(N, state->in, state->out, FFTW_FORWARD, FFTW_MEASURE); srandom(0); for (i=0; i<N; i++) state->in[i] = (float)(random() & 0xfff) / 256.0f; }
static cfftw_info *cfftw_getplan(int n,int fwd) { cfftw_info *info; int logn = ilog2(n); if (logn < MINFFT || logn > MAXFFT) return (0); info = (fwd?cfftw_fwd:cfftw_bwd)+(logn-MINFFT); if (!info->plan) { info->in = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * n); info->out = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * n); info->plan = fftwf_plan_dft_1d(n, info->in, info->out, fwd?FFTW_FORWARD:FFTW_BACKWARD, FFTW_MEASURE); } return info; }
int dft_plan_c2c(const int dft_points, dft_dir_t dir, dft_plan_t *plan) { int sign; sign = (dir == FORWARD) ? FFTW_FORWARD : FFTW_BACKWARD; allocate(plan,sizeof(fftwf_complex),sizeof(fftwf_complex), dft_points); plan->p = fftwf_plan_dft_1d(dft_points, plan->in, plan->out, sign, 0U); if (!plan->p) { return -1; } plan->size = dft_points; plan->mode = COMPLEX_2_COMPLEX; return 0; }
void ansi_air_bang(t_ansi_air *x) { float fs = x->fs; float TempC = x->tempC; float Hum = x->hum; float Pressure = x->pressure; float Distance = x->dist; int i, fftlength = x->fftlength; int fftlengthhalf = x->fftlengthhalf; float f2[fftlengthhalf], air[fftlengthhalf]; float _Complex Hair[fftlengthhalf], Hair2[fftlengthhalf], H[fftlength], h[fftlength]; static float msli_pi = 3.141592653589793; fftwf_plan p_h; for(i = 0; i < fftlength; i++) { if( i < fftlengthhalf ) { f2[i] = (fs * (float)i) / ((float)fftlength); // -1.0 is to change into negative dB (attenation) air[i] = -1.0 * Distance * fnMAPPAttenuate(TempC,Pressure,Hum,f2[i]); Hair[i] = cpowf(10.0,air[i]/20.0); // delay it to middle of window for linear phase (causual) filter Hair2[i] = Hair[i] * cexpf(-I * 2.0 * msli_pi * f2[i] * (fftlength/4 * (1.0 / fs))); H[i] = Hair2[i]; } else { H[i] = conjf(Hair2[ (fftlength/2 -1) - (i-fftlengthhalf)]); } } p_h = fftwf_plan_dft_1d(fftlength,H,h,FFTW_BACKWARD,FFTW_ESTIMATE); fftwf_execute(p_h); for(i = 0; i < fftlength; i++) { h[i] = h[i] / fftlength; outlet_float((t_outlet *)x->outlet2, i); outlet_float((t_outlet *)x->outlet1, crealf(h[i])); } outlet_anything((t_outlet *)x->outinfo, gensym("done"), 0, NULL); }
/* complex FFT ----------------------------------------------------------------- * cpx=fft(cpx) * args : fftwf_plan plan I fftw plan (NULL: create new plan) * cpx_t *cpx I/O input/output complex data * int n I number of input/output data * return : none *-----------------------------------------------------------------------------*/ extern void cpxfft(fftwf_plan plan, cpx_t *cpx, int n) { #ifdef FFTMTX mlock(hfftmtx); #endif if (plan==NULL) { fftwf_plan_with_nthreads(NFFTTHREAD); /* fft execute in multi threads */ plan=fftwf_plan_dft_1d(n,cpx,cpx,FFTW_FORWARD,FFTW_ESTIMATE); fftwf_execute_dft(plan,cpx,cpx); /* fft */ fftwf_destroy_plan(plan); } else { fftwf_execute_dft(plan,cpx,cpx); /* fft */ } #ifdef FFTMTX unmlock(hfftmtx); #endif }
float* fir_fsamp_odd (int N, float* A, int rtype, float scale, int wintype) { int i, j; int mid = (N - 1) / 2; float mag, phs; float* window; float *fcoef = (float *) malloc0 (N * sizeof (complex)); float *c_impulse = (float *) malloc0 (N * sizeof (complex)); fftwf_plan ptmp = fftwf_plan_dft_1d(N, (fftwf_complex *)fcoef, (fftwf_complex *)c_impulse, FFTW_BACKWARD, FFTW_PATIENT); float local_scale = 1.0 / (float)N; for (i = 0; i <= mid; i++) { mag = A[i] * local_scale; phs = - (float)mid * TWOPI * (float)i / (float)N; fcoef[2 * i + 0] = mag * cos (phs); fcoef[2 * i + 1] = mag * sin (phs); } for (i = mid + 1, j = 0; i < N; i++, j++) { fcoef[2 * i + 0] = + fcoef[2 * (mid - j) + 0]; fcoef[2 * i + 1] = - fcoef[2 * (mid - j) + 1]; } fftwf_execute (ptmp); fftwf_destroy_plan (ptmp); _aligned_free (fcoef); window = get_fsamp_window(N, wintype); switch (rtype) { case 0: for (i = 0; i < N; i++) c_impulse[i] = scale * c_impulse[2 * i] * window[i]; break; case 1: for (i = 0; i < N; i++) { c_impulse[2 * i + 0] *= scale * window[i]; c_impulse[2 * i + 1] = 0.0; } break; } _aligned_free (window); return c_impulse; }
SIPHON create_siphon (int run, int insize, float* in, int sipsize, int fftsize, int specmode) { SIPHON a = (SIPHON) malloc0 (sizeof (siphon)); a->run = run; a->insize = insize; a->in = in; a->sipsize = sipsize; // NOTE: sipsize MUST BE A POWER OF TWO!! a->sipbuff = (float *) malloc0 (a->sipsize * sizeof (complex)); a->idx = 0; a->sipout = (float *) malloc0 (a->sipsize * sizeof (complex)); a->fftsize = fftsize; a->specout = (float *) malloc0 (a->fftsize * sizeof (complex)); a->specmode = specmode; a->sipplan = fftwf_plan_dft_1d (a->fftsize, (fftwf_complex *)a->sipout, (fftwf_complex *)a->specout, FFTW_FORWARD, FFTW_PATIENT); a->window = (float *) malloc0 (a->fftsize * sizeof (complex)); InitializeCriticalSectionAndSpinCount(&a->update, 2500); build_window (a); return a; }
extern void cpxfft(fftwf_plan plan, cpx_t *cpx, int n) { #ifdef TEST if (plan==NULL) { mlock(hfftmtx); fftwf_plan_with_nthreads(NFFTTHREAD); /* fft execute in multi threads */ plan=fftwf_plan_dft_1d(n,cpx,cpx,FFTW_FORWARD,FFTW_ESTIMATE); fftwf_execute_dft(plan,cpx,cpx); /* fft */ fftwf_destroy_plan(plan); unmlock(hfftmtx); } else { fftwf_execute_dft(plan,cpx,cpx); /* fft */ } #else sfft_plan *p; p=sfft_make_plan(n, 50, SFFT_VERSION_3, FFTW_ESTIMATE); sfft_exec(p, cpx, cpx); #endif }
/**@ingroup genPSStime_seq * This module generate the PSS time sequence for the different FFT size * \param cellID: Identifies the sequence number: 0, 1, 2 * \param FFTsize: define the size of the OFMD symbols: 128, 256, 512, 1024, 1536 o 2048 * \param TxRxmode: defines if the sequence generate is for Tx or Rx side */ int genPSStime_seq(int cellID, int FFTsize, fftwf_complex *PSS_time, int TxRxmode){ int s, j, i; _Complex float PSS_ID[PSSLEN+2]; /**FFT*/ fftwf_complex PSS_freq[2048]; fftwf_plan plan64, plan128, plan256, plan512, plan1024, plan1536, plan2048; /**Select cellID: 0, 1, 2*/ setPSS(cellID, PSS_ID, TxRxmode); //TX PSS: ROTATE memset(PSS_freq, 0, sizeof(_Complex float)*FFTsize); s=1; //DC at position O for(i=PSSLEN/2; i<PSSLEN; i++){ PSS_freq[s] = PSS_ID[i]; s++; } s=(FFTsize-(PSSLEN/2)); for(i=0; i<PSSLEN/2; i++){ PSS_freq[s] = PSS_ID[i]; s++; } if(FFTsize==64){ plan64 = fftwf_plan_dft_1d(64, PSS_freq, PSS_time, FFTW_BACKWARD, FFTW_ESTIMATE); fftwf_execute(plan64); } if(FFTsize==128){ plan128 = fftwf_plan_dft_1d(128, PSS_freq, PSS_time, FFTW_BACKWARD, FFTW_ESTIMATE); fftwf_execute(plan128); } if(FFTsize==512){ plan512 = fftwf_plan_dft_1d(512, PSS_freq, PSS_time, FFTW_BACKWARD, FFTW_ESTIMATE); fftwf_execute(plan512); } if(FFTsize==1024){ plan1024 = fftwf_plan_dft_1d(1024, PSS_freq, PSS_time, FFTW_BACKWARD, FFTW_ESTIMATE); fftwf_execute(plan1024); } if(FFTsize==1536){ plan1536 = fftwf_plan_dft_1d(1536, PSS_freq, PSS_time, FFTW_BACKWARD, FFTW_ESTIMATE); fftwf_execute(plan1536); } if(FFTsize==2048){ plan2048 = fftwf_plan_dft_1d(2048, PSS_freq, PSS_time, FFTW_BACKWARD, FFTW_ESTIMATE); fftwf_execute(plan2048); } return 0; }
void init_monitor() { int i; // prepare the fft (time domain to frequency domain) timebuf=(fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*BUFFER_SIZE); freqbuf=(fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*BUFFER_SIZE); plan=fftwf_plan_dft_1d(BUFFER_SIZE,timebuf,freqbuf,FFTW_FORWARD,FFTW_ESTIMATE); result=malloc(BUFFER_SIZE*sizeof(float)); filter=blackman_harris_filter(BUFFER_SIZE); waterfall=malloc(WIDTH*sizeof(float)); iq_points=calloc(WIDTH,sizeof(GdkPoint)); for(i=0;i<WIDTH;i++) { iq_points[i].x=i; iq_points[i].y=50; } plot_color.red=65535; plot_color.green=65535; plot_color.blue=65535; }