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