/*************************************************************************** * Copyright (C) 2005-2012 by Adam Deller & Richard Dodson * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ //=========================================================================== // SVN properties (DO NOT CHANGE) // // $Id$ // $HeadURL$ // $LastChangedRevision$ // $Author$ // $LastChangedDate$ // //============================================================================ /** \file architecture.h * \brief File contains mapping for vector functions to specific architectures */ #ifndef ARCHITECTURE_H #define ARCHITECTURE_H #define INTEL 1 #define AMD 2 #define GENERIC 3 //define the MPI tags #define CR_TERMINATE 0 #define CR_VALIDVIS 1 #define CR_RECEIVETIME 2 #define CR_PROCESSDATA 3 #define CR_PROCESSCONTROL 4 #define DS_TERMINATE 5 #define DS_PROCESS 6 //define the architecture to be compiled for here #if @ipp_enabled@ #define ARCH INTEL #endif //if no architecture is selected, default to generic #ifndef ARCH #define ARCH GENERIC #endif //set up the function mapping for the intel architecture #if(ARCH == INTEL) #include #include #include #include #ifdef IPP9 #define IPP_9_API #elif(IPP_VERSION_MAJOR == 2018) #define IPP_9_API #elif(IPP_VERSION_MAJOR == 2019) #define IPP_9_API #endif //start with the data types #define u8 Ipp8u #define u16 Ipp16u #define s16 Ipp16s #define cs16 Ipp16sc #define s32 Ipp32s #define u32 Ipp32u #define f32 Ipp32f #define cf32 Ipp32fc #define cf64 Ipp64fc #define f64 Ipp64f #define s64 Ipp64s #define u64 Ipp64u //and the constant values #define vecFFTSpecR_f32 IppsFFTSpec_R_32f #define vecFFTSpecC_f32 IppsFFTSpec_C_32f #define vecFFTSpecC_cf32 IppsFFTSpec_C_32fc #define vec2DFFTSpecC_cf32 IppiFFTSpec_C_32fc #define vecDFTSpecC_cf32 IppsDFTSpec_C_32fc #define vecDFTSpecR_f32 IppsDFTSpec_R_32f #define vecFFTSpec_s16 IppsFFTSpec_R_16s #define vecHintAlg IppHintAlgorithm #define vecRndZero ippRndZero #define vecRndNear ippRndNear #define vecHamming ippWinHamming #define vecTrue ippTrue #define MAX_S32 IPP_MAX_32S #define MAX_U32 IPP_MAX_32U #define MAX_S16 IPP_MAX_16S #define MIN_S16 IPP_MIN_16S #define MAX_U16 IPP_MAX_16U #define TWO_PI IPP_2PI #define vecFFT_NoReNorm IPP_FFT_NODIV_BY_ANY #define vecFFT_ReNorm IPP_FFT_DIV_INV_BY_N #define vecAlgHintFast ippAlgHintFast #define vecAlgHintAccurate ippAlgHintAccurate #define vecNoErr ippStsNoErr #define vecStatus IppStatus //now the vector functions themselves #define vectorAlloc_u8(length) ippsMalloc_8u(length) #define vectorAlloc_s16(length) ippsMalloc_16s(length) #define vectorAlloc_cs16(length) ippsMalloc_16sc(length) #define vectorAlloc_s32(length) ippsMalloc_32s(length) #define vectorAlloc_f32(length) ippsMalloc_32f(length) #define vectorAlloc_cf32(length) ippsMalloc_32fc(length) #define vectorAlloc_f64(length) ippsMalloc_64f(length) #define vectorAlloc_cf64(length) ippsMalloc_64fc(length) #define vectorFree(memptr) ippsFree(memptr) #define vectorAdd_f32_I(src, srcdest, length) ippsAdd_32f_I(src, srcdest, length) #define vectorAdd_f64_I(src, srcdest, length) ippsAdd_64f_I(src, srcdest, length) #define vectorAdd_s16_I(src, srcdest, length) ippsAdd_16s_I(src, srcdest, length) #define vectorAdd_s32_I(src, srcdest, length) ippsAdd_32s_ISfs(src, srcdest, length, 0) #define vectorAdd_cf32_I(src, srcdest, length) ippsAdd_32fc_I(src, srcdest, length) #define vectorAdd_cf64_I(src, srcdest, length) ippsAdd_64fc_I(src, srcdest, length) #define vectorAdd_f32(src1, src2, dest, length) ippsAdd_32f(src1, src2, dest, length) #define vectorAdd_f64(src1, src2, dest, length) ippsAdd_64f(src1, src2, dest, length) #define vectorAdd_s16(src1, src2, dest, length) ippsAdd_16s(src1, src2, dest, length) #define vectorAdd_s32(src1, src2, dest, length) ippsAdd_32s_Sfs(src1, src2, dest, length, 0) #define vectorAdd_cf32(src1, src2, dest, length) ippsAdd_32fc_I(src1, src2, dest, length) #define vectorAdd_cf64(src1, src2, dest, length) ippsAdd_64fc_I(src1, src2, dest, length) #define vectorAddC_f64(src, val, dest, length) ippsAddC_64f(src, val, dest, length) #define vectorAddC_f32(src, val, dest, length) ippsAddC_32f(src, val, dest, length) #define vectorAddC_f32_I(val, srcdest, length) ippsAddC_32f_I(val, srcdest, length) #define vectorAddC_s16_I(val, srcdest, length) ippsAddC_16s_I(val, srcdest, length) #define vectorAddC_f64_I(val, srcdest, length) ippsAddC_64f_I(val, srcdest, length) #define vectorAddProduct_cf32(src1, src2, accumulator, length) ippsAddProduct_32fc(src1, src2, accumulator, length) #define vectorConj_cf32(src, dest, length) ippsConj_32fc(src, dest, length) #define vectorConjFlip_cf32(src, dest, length) ippsConjFlip_32fc(src, dest, length) #define vectorCopy_u8(src, dest, length) ippsCopy_8u(src, dest, length) #define vectorCopy_s16(src, dest, length) ippsCopy_16s(src, dest, length) #define vectorCopy_s32(src, dest, length) ippsCopy_32f((f32*)src, (f32*)dest, length) #define vectorCopy_f32(src, dest, length) ippsCopy_32f(src, dest, length) #define vectorCopy_cf32(src, dest, length) ippsCopy_32fc(src, dest, length) #define vectorCopy_f64(src, dest, length) ippsCopy_64f(src, dest, length) #define vectorCos_f32(src, dest, length) ippsCos_32f_A11(src, dest, length) #define vectorConvertScaled_s16f32(src, dest, length, scalefactor) ippsConvert_16s32f_Sfs(src, dest, length, scalefactor) #define vectorConvertScaled_f32s16(src, dest, length, rndmode, scalefactor) ippsConvert_32f16s_Sfs(src, dest, length, rndmode, scalefactor) #define vectorConvertScaled_f32u8(src, dest, length, rndmode, scalefactor) ippsConvert_32f8u_Sfs(src, dest, length, rndmode, scalefactor) #define vectorConvert_f32s32(src, dest, length, rndmode) ippsConvert_32f32s_Sfs(src, dest, length, rndmode, 0) #define vectorConvert_s16f32(src, dest, length) ippsConvert_16s32f(src, dest, length) #define vectorConvert_s32f32(src, dest, length) ippsConvert_32s32f(src, dest, length) #define vectorConvert_f64f32(src, dest, length) ippsConvert_64f32f(src, dest, length) #define vectorDivide_f32(src1, src2, dest, length) ippsDiv_32f(src1, src2, dest, length) #define vectorDivC_cf32_I(val, srcdest, length) ippsDivC_32fc_I(val, srcdest, length) #define vectorDivC_f32_I(val, srcdest, length) ippsDivC_32f_I(val, srcdest, length) #define vectorDotProduct_f64(src1, src2, length, output) ippsDotProd_64f(src1, src2, length, output) #define vectorFlip_f64_I(srcdest, length) ippsFlip_64f_I(srcdest, length) #define vectorFlip_cf32(src, dest, length) ippsFlip_32fc(src, dest, length) #define vectorMagnitude_cf32(src, dest, length) ippsMagnitude_32fc(src, dest, length) #define vectorMean_cf32(src, length, mean, hint) ippsMean_32fc(src, length, mean, hint) #define vectorMul_f32(src1, src2, dest, length) ippsMul_32f(src1, src2, dest, length) #define vectorMul_f32_I(src, srcdest, length) ippsMul_32f_I(src, srcdest, length) #define vectorMul_cf32_I(src, srcdest, length) ippsMul_32fc_I(src, srcdest, length) #define vectorMul_cf32(src1, src2, dest, length) ippsMul_32fc(src1, src2, dest, length) #define vectorMul_f32cf32(src1, src2, dest, length) ippsMul_32f32fc(src1, src2, dest, length) #define vectorMulC_f32(src, val, dest, length) ippsMulC_32f(src, val, dest, length) #define vectorMulC_cs16_I(val, srcdest, length) ippsMulC_16sc_ISfs(val, srcdest, length, 0) #define vectorMulC_f32_I(val, srcdest, length) ippsMulC_32f_I(val, srcdest, length) #define vectorMulC_cf32_I(val, srcdest, length) ippsMulC_32fc_I(val, srcdest, length) #define vectorMulC_cf32(src, val, dest, length) ippsMulC_32fc(src, val, dest, length) #define vectorMulC_f64_I(val, srcdest, length) ippsMulC_64f_I(val, srcdest, length) #define vectorMulC_f64(src, val, dest, length) ippsMulC_64f(src, val, dest, length) #define vectorPhase_cf32(src, dest, length) ippsPhase_32fc(src, dest, length) #define vectorRealToComplex_f32(real, imag, complex, length) ippsRealToCplx_32f(real, imag, complex, length) #define vectorReal_cf32(complex, real, length) ippsReal_32fc(complex, real, length) #define vectorSet_f32(val, dest, length) ippsSet_32f(val, dest, length) #define vectorSin_f32(src, dest, length) ippsSin_32f_A11(src, dest, length) #define vectorSinCos_f32(src, sin, cos, length) ippsSinCos_32f_A11(src, sin, cos, length) #ifdef IPP_9_API #define vectorSplitScaled_s16f32(src, dest, numchannels, chanlen) genericSplitScaled_16s32f(src, dest, numchannels, chanlen) #else #define vectorSplitScaled_s16f32(src, dest, numchannels, chanlen) ippsSplitScaled_16s32f_D2L(src, dest, numchannels, chanlen) #endif #define vectorSquare_f32_I(srcdest, length) ippsSqr_32f_I(srcdest, length) #define vectorSquare_f64_I(srcdest, length) ippsSqr_64f_I(srcdest, length) #define vectorSub_f32_I(src, srcdest, length) ippsSub_32f_I(src, srcdest, length) #define vectorSub_s32(src1, src2, dest, length) ippsSub_32s_Sfs(src1, src2, dest, length, 0) #define vectorSub_cf32_I(src, srcdest, length) ippsSub_32fc_I(src, srcdest, length) #define vectorSub_cf32(src1, src2, dest, length) ippsSub_32fc(src1, src2, dest, length) #define vectorSum_cf32(src, length, sum, hint) ippsSum_32fc(src, length, sum, hint) #define vectorZero_u8(dest, length) ippsZero_8u(dest, length) #define vectorZero_cf32(dest, length) ippsZero_32fc(dest, length) #define vectorZero_cf64(dest, length) ippsZero_64fc(dest, length) #define vectorZero_f32(dest, length) ippsZero_32f(dest, length) #define vectorZero_s16(dest, length) ippsZero_16s(dest, length) #define vectorZero_s32(dest, length) genericZero_32s(dest, length) #define vectorMax_f32(src, dest, length) ippsMax_32f(src, dest, length) #define vectorMin_f32(src, dest, length) ippsMin_32f(src, dest, length) #define vectorMove_cf32(src, dest, length) ippsMove_32fc(src, dest, length) #define vectorMove_f32(src, dest, length) ippsMove_32f(src, dest, length) #define vectorStdDev_f32(src, length, stddev, hint) ippsStdDev_32f(src,length, stddev, hint) #define vectorAbs_f32_I(srcdest, length) ippsAbs_32f_I(srcdest,length) #define vectorMaxIndx_f32(srcdest, length, max, imax) ippsMaxIndx_32f(srcdest,length, max, imax) #define vectorFFTInv_CCSToR_32f(src, dest,fftspec,buff) ippsFFTInv_CCSToR_32f(src, dest,fftspec,buff) // Get Error string #define vectorGetStatusString(code) ippGetStatusString(code) // FFT Functions #ifdef IPP_9_API inline vecStatus vectorInitFFTR_f32(vecFFTSpecR_f32 **fftspec, int order, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **fftworkbuf) { // Alloc FFT buffers int sizeFFTSpec, sizeFFTInitBuf; u8 *fftInitBuf, *fftSpecBuf; ippsFFTGetSize_R_32f(order, flag, hint, &sizeFFTSpec, &sizeFFTInitBuf, wbufsize); fftSpecBuf = ippsMalloc_8u(sizeFFTSpec); fftInitBuf = ippsMalloc_8u(sizeFFTInitBuf); *fftworkbuf = ippsMalloc_8u(*wbufsize); // Initialize FFT ippsFFTInit_R_32f(fftspec, order, flag, hint, fftSpecBuf, fftInitBuf); if (fftInitBuf) ippFree(fftInitBuf); return vecNoErr; } #define vectorInitFFTC_f32(fftspec, order, flag, hint) ippsFFTInitAlloc_C_32f(fftspec, order, flag, hint) inline vecStatus vectorInitFFTC_cf32(vecFFTSpecC_cf32 **fftspec, int order, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **fftworkbuf) { // Alloc FFT buffers int sizeFFTSpec, sizeFFTInitBuf; u8 *fftInitBuf, *fftSpecBuf; ippsFFTGetSize_C_32fc(order, flag, hint, &sizeFFTSpec, &sizeFFTInitBuf, wbufsize); fftSpecBuf = ippsMalloc_8u(sizeFFTSpec); fftInitBuf = ippsMalloc_8u(sizeFFTInitBuf); *fftworkbuf = ippsMalloc_8u(*wbufsize); // Initialize FFT ippsFFTInit_C_32fc(fftspec, order, flag, hint, fftSpecBuf, fftInitBuf); if (fftInitBuf) ippFree(fftInitBuf); return vecNoErr; } inline vecStatus vectorInitDFTC_cf32(vecDFTSpecC_cf32 **dftspec, int length, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **dftworkbuf) { // Alloc DFT buffers int sizeDFTSpec, sizeDFTInitBuf; u8 *dftInitBuf; ippsDFTGetSize_C_32fc(length, flag, hint, &sizeDFTSpec, &sizeDFTInitBuf, wbufsize); *dftspec = (IppsDFTSpec_C_32fc*)ippsMalloc_8u(sizeDFTSpec); dftInitBuf = ippsMalloc_8u(sizeDFTInitBuf); *dftworkbuf = ippsMalloc_8u(*wbufsize); // Initialize DFT ippsDFTInit_C_32fc(length, flag, hint, *dftspec, dftInitBuf); if (dftInitBuf) ippFree(dftInitBuf); return vecNoErr; } inline vecStatus vectorInitDFTR_f32(vecDFTSpecR_f32 **dftspec, int length, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **dftworkbuf) { // Alloc DFT buffers int sizeDFTSpec, sizeDFTInitBuf; u8 *dftInitBuf; ippsDFTGetSize_R_32f(length, flag, hint, &sizeDFTSpec, &sizeDFTInitBuf, wbufsize); *dftspec = (IppsDFTSpec_R_32f*)ippsMalloc_8u(sizeDFTSpec); dftInitBuf = ippsMalloc_8u(sizeDFTInitBuf); *dftworkbuf = ippsMalloc_8u(*wbufsize); // Initialize DFT ippsDFTInit_R_32f(length, flag, hint, *dftspec, dftInitBuf); if (dftInitBuf) ippFree(dftInitBuf); return vecNoErr; } #define vectorFreeFFTR_f32(fftspec) ippFree(fftspec) #define vectorFreeFFTC_f32(fftspec) ippFree(fftspec) #define vectorFreeFFTC_cf32(fftspec) ippFree(fftspec) #define vectorFreeDFTC_cf32(fftspec) ippFree(fftspec) #define vectorFreeDFTR_f32(fftspec) ippFree(fftspec) #define vectorFreeDFTC_f32(fftspec) ippFree(fftspec) #else inline vecStatus vectorInitFFTR_f32(vecFFTSpecR_f32 **fftspec, int order, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **fftworkbuf) { vecStatus status = ippsFFTInitAlloc_R_32f(fftspec, order, flag, hint); if (status != vecNoErr) return(status); status = ippsFFTGetBufSize_R_32f(*fftspec, wbufsize); if (status != vecNoErr) return(status); *fftworkbuf = ippsMalloc_8u(*wbufsize); return vecNoErr; } inline vecStatus vectorInitFFTC_cf32(vecFFTSpecC_cf32 **fftspec, int order, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **fftworkbuf) { vecStatus status = ippsFFTInitAlloc_C_32fc(fftspec, order, flag, hint); if (status != vecNoErr) return(status); status = ippsFFTGetBufSize_C_32fc(*fftspec, wbufsize); if (status != vecNoErr) return(status); *fftworkbuf = ippsMalloc_8u(*wbufsize); return vecNoErr; } inline vecStatus vectorInitDFTC_cf32(vecDFTSpecC_cf32 **dftspec, int length, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **dftworkbuf) { vecStatus status = ippsDFTInitAlloc_C_32fc(dftspec, length, flag, hint); if (status != vecNoErr) return(status); status = ippsDFTGetBufSize_C_32fc(*dftspec, wbufsize); if (status != vecNoErr) return(status); *dftworkbuf = ippsMalloc_8u(*wbufsize); return vecNoErr; } inline vecStatus vectorInitDFTR_f32(vecDFTSpecR_f32 **dftspec, int length, int flag, IppHintAlgorithm hint, int *wbufsize, u8 **dftworkbuf) { vecStatus status = ippsDFTInitAlloc_R_32f(dftspec, length, flag, hint); if (status != vecNoErr) return(status); status = ippsDFTGetBufSize_R_32f(*dftspec, wbufsize); if (status != vecNoErr) return(status); *dftworkbuf = ippsMalloc_8u(*wbufsize); return vecNoErr; } #define vectorFreeFFTR_f32(fftspec) ippsFFTFree_R_32f(fftspec) #define vectorFreeFFTC_f32(fftspec) ippsFFTFree_C_32f(fftspec) #define vectorFreeFFTC_cf32(fftspec) ippsFFTFree_C_32fc(fftspec) #define vectorFreeDFTC_cf32(fftspec) ippsDFTFree_C_32fc(fftspec) #define vectorFreeDFTR_f32(fftspec) ippsDFTFree_R_32f(fftspec) #define vectorFreeDFTC_f32(fftspec) ippsDFTFree_R_32f(fftspec) #endif #define vectorFFT_RtoC_f32(src, dest, fftspec, fftbuffer) ippsFFTFwd_RToCCS_32f(src, dest, fftspec, fftbuffer) #define vectorFFT_CtoC_f32(srcre, srcim, destre, destim, fftspec, fftbuff) ippsFFTFwd_CToC_32f(srcre, srcim, destre, destim, fftspec, fftbuff) #define vectorFFT_CtoC_cf32(src, dest, fftspec, fftbuff) ippsFFTFwd_CToC_32fc(src, dest, fftspec, fftbuff) #define vectorDFT_CtoC_cf32(src, dest, fftspec, fftbuff) ippsDFTFwd_CToC_32fc(src, dest, fftspec, fftbuff) #define vectorDFT_RtoC_f32(src, dest, fftspec, fftbuff) ippsDFTFwd_RToCCS_32f(src, dest, fftspec, fftbuff) //#define vectorFFT_RtoC_f32(src, dest, fftspec, fftbuffer) ippsDFTFwd_RToCCS_32f(src, dest, fftspec, fftbuffer) #define vectorScaledFFT_RtoC_s16(src, dest, fftspec, fftbuffer, scale) ippsFFTFwd_RToCCS_16s_Sfs(src, dest, fftspec, fftbuffer, scale) #define vectorGenerateFIRLowpass_f64(freq, taps, length, window, normalise) ippsFIRGenLowpass_64f(freq, taps, length, window, normalise) // For difx_monitor // Note 2D #define vector2DFFT_CtoC_cf32(src, sstp, dest, dstp, fftspec, fftbuff) ippiFFTFwd_CToC_32fc_C1R(src, sstp, dest, dstp, fftspec, fftbuff) #define vector2DFreeFFTC_cf32(fftspec) ippiFFTFree_C_32fc(fftspec) #define vector2DInitFFTC_cf32(fftspec, orderx, ordery, flag, hint) ippiFFTInitAlloc_C_32fc(fftspec, orderx, ordery, flag, hint) #define vectorSqrt_f32_I(srcdest, len) ippsSqrt_32f_I(srcdest, len) #include #include #include #endif /*Architecture == Intel */ #if(ARCH == AMD) // Use FRAMEWAVE? #error "Sorry: AMD not yet implemented" #endif /*Architecture == AMD */ #if (ARCH == GENERIC) // Using FFTW #include #define u8 uint8_t #define u16 uint16_t #define s16 int16_t #define cs16 complex short #define s32 int32_t #define u32 uint32_t #define f32 float #define f64 double #define cf32 fc32 // fftwf_complex #define cf64 fc64 // fftw_complex #define s64 int64_t #define u64 uint64_t #define vecStatus int //and the constant values #define vecFFTSpecR_f32 GenFFTPtrRf32 #define vecFFTSpecC_f32 GenFFTPtrCf32 // not used #define vecFFTSpecC_cf32 GenFFTPtrCfc32 #define vecDFTSpecC_cf32 GenFFTPtrCfc32 #define vecDFTSpecR_f32 GenFFTPtrRf32 #define vecNoErr 0 #define vecTrue 1 #define MAX_S16 ((1<<15) - 1) #define MIN_S16 (-(1<<15)) #define MAX_U16 ((1<<16) - 1) #define MAX_S32 MAX_S16 // ((1<<31) - 1) #define MAX_U32 MAX_U16 // ((1<<32) - 1) #define TWO_PI 6.283185307179586476925286766559 #define vecHintAlg int #define vecFFT_NoReNorm 0 // FFTW is always no renomalise #define vecFFT_ReNorm 0 // FFTW is always no renomalise #define vecAlgHintFast 0 // FFTW is always Fast #define vecAlgHintAccurate 0 //vector allocation and deletion routines #define vectorAlloc_u8(length) new u8[length] #define vectorAlloc_s16(length) new s16[length] #define vectorAlloc_cs16(length) new cs16[length] #define vectorAlloc_s32(length) new s32[length] #define vectorAlloc_f32(length) new f32[length] #define vectorAlloc_cf32(length) new cf32[length] #define vectorAlloc_f64(length) new f64[length] #define vectorAlloc_cf64(length) new cf64[length] #define vectorFree(memptr) delete [] memptr #include #include #include #include //start with the types typedef struct { short re; short im; } sc16; // Danger here: fftw_complex value[1] is equivilent to float value[0]=real part and value[1]=imag part. // These structures are implicitly the same, but is it guaranteed? typedef struct { float re; float im; } fc32; // = fftwf_complex typedef struct { double re; double im; } fc64; // = fftw_complex // These fill in for the IppsFFTSpec_R_32f structures. typedef struct { fftwf_plan p; f32 * in; cf32 * out; // Perhaps should be fftwf_complex int len; int len2; int len3; } GenFFTPtrRf32; typedef struct { fftwf_plan p; f32 * out; cf32 * in; // Perhaps should be fftwf_complex int len; int len2; int len3; } GenFFTPtrCRf32; typedef struct { fftwf_plan p; cf32 * in; // Perhaps should be fftwf_complex cf32 * out; // Perhaps should be fftwf_complex int len; int len2; int len3; } GenFFTPtrCfc32; typedef struct { fftwf_plan p; f32 * in_re; f32 * in_im; f32 * out_re; f32 * out_im; int len; int len2; int len3; } GenFFTPtrCf32; typedef struct { fftw_plan p; cf64 * in; cf64 * out; int len; int len2; int len3; } GenFFTPtrC64; //then the generic functions // Copy // Replace with memmove(d,s,l*size(d[0])) inline vecStatus genericCopy_u8(const u8 * src, u8 * dest, int length) { for(int i=0;i(src[i]*tmp); return vecNoErr; } /* #define vectorConvertScaled_f32u8(src, dest, length, rndmode, scalefactor) ippsConvert_32f8u_Sfs(src, dest, length, rndmode, scalefactor) */ inline vecStatus genericConvert_32f8u(const f32 *src, u8 *dest, int length, int rndmode, int scalefactor) {f32 tmp;tmp=powf(2,-scalefactor); for(int i=0;i(src[i]*tmp); return vecNoErr; } /* #define vectorConvert_f32s32(src, dest, length, rndmode) ippsConvert_32f32s_Sfs(src, dest, length, rndmode, 0) */ inline vecStatus genericConvert_32f32s(const f32 * src, s32 * dest, int length, int rndmode) // Have not included rounding mode!!! { for(int i=0;i(src[i]); return vecNoErr; } inline vecStatus genericConvert_16s32f(const s16 * src, f32 * dest, int length) { for(int i=0;ival[i])? max[0]:val[i]; return vecNoErr; } //#define vectorMin_f32(src, dest, length) ippsMin_32f(src, dest, length) inline vecStatus genericMin_32f(const f32 *val, int length, f32 *min) { min[0]=1E30; for(int i=0;i0) {mean[0].re /= length; mean[0].im /= length;} return vecNoErr; } /* #define vectorMul_f32(src1, src2, dest, length) ippsMul_32f(src1, src2, dest, length) */ inline vecStatus genericMul_32f(const f32 *src1, const f32 *src2, f32 *dest, int length) { for(int i=0;i extern pthread_mutex_t FFTinitMutex; inline vecStatus genericInitDFTR_f32(GenFFTPtrRf32 **fftspec, int length, int flag, vecHintAlg hint, int *wbufsize, u8 **fftworkbuf) { fftspec[0] = (GenFFTPtrRf32 *) malloc(sizeof(GenFFTPtrRf32)); fftspec[0]->len = length; fftspec[0]->len2 = 1; fftspec[0]->len3 = 1; fftspec[0]->in = (f32 *) fftwf_malloc(fftspec[0]->len*sizeof(f32)); fftspec[0]->out = (cf32 *) fftwf_malloc((fftspec[0]->len/2+1)*sizeof(cf32)); pthread_mutex_lock(&FFTinitMutex); fftspec[0]->p = fftwf_plan_dft_r2c_1d(fftspec[0]->len,fftspec[0]->in, (fftwf_complex *) fftspec[0]->out, FFTW_ESTIMATE); pthread_mutex_unlock(&FFTinitMutex); return vecNoErr; } // Always FORWARD inline vecStatus genericInitDFTCR_f32(GenFFTPtrCRf32 **fftspec, int length, int flag, vecHintAlg hint, int *wbufsize, u8 **fftworkbuf) { fftspec[0] = (GenFFTPtrCRf32 *) malloc(sizeof(GenFFTPtrCRf32)); fftspec[0]->len = length; fftspec[0]->len2 = 1; fftspec[0]->len3 = 1; fftspec[0]->out = (f32 *) fftwf_malloc(fftspec[0]->len*sizeof(f32)); fftspec[0]->in = (cf32 *) fftwf_malloc((fftspec[0]->len/2+1)*sizeof(cf32)); pthread_mutex_lock(&FFTinitMutex); fftspec[0]->p = fftwf_plan_dft_c2r_1d(fftspec[0]->len,(fftwf_complex *) fftspec[0]->in, fftspec[0]->out, FFTW_ESTIMATE); pthread_mutex_unlock(&FFTinitMutex); return vecNoErr; } // Always BACKWARDS inline vecStatus genericInitDFTC_cf32(GenFFTPtrCfc32 **fftspec, int length, int flag, vecHintAlg hint, int *wbufsize, u8 **fftworkbuf) { fftspec[0] = (GenFFTPtrCfc32 *) malloc(sizeof(GenFFTPtrCfc32)); fftspec[0]->len = length; fftspec[0]->len2 = 1; fftspec[0]->len3 = 1; fftspec[0]->in = (cf32 *) fftwf_malloc(fftspec[0]->len*sizeof(cf32)); fftspec[0]->out = (cf32 *) fftwf_malloc(fftspec[0]->len*sizeof(cf32)); pthread_mutex_lock(&FFTinitMutex); fftspec[0]->p = fftwf_plan_dft_1d(fftspec[0]->len,(fftwf_complex *) fftspec[0]->in,(fftwf_complex *) fftspec[0]->out, FFTW_FORWARD, FFTW_ESTIMATE); pthread_mutex_unlock(&FFTinitMutex); *wbufsize = 0; *fftworkbuf = 0; return vecNoErr; } // Always FORWARD inline vecStatus genericInitFFTC_cf32(GenFFTPtrCfc32 **fftspec, int order, int flag, vecHintAlg hint, int *wbufsize, u8 **fftworkbuf) { return genericInitDFTC_cf32(fftspec, 1<len = ox; fftspec[0]->len2 = oy; fftspec[0]->len3 = 1; fftspec[0]->in = (cf32 *) fftwf_malloc(fftspec[0]->len*sizeof(cf32)); fftspec[0]->out = (cf32 *) fftwf_malloc(fftspec[0]->len*sizeof(cf32)); pthread_mutex_lock(&FFTinitMutex); fftspec[0]->p = fftwf_plan_dft_2d(ox,oy,(fftwf_complex *) fftspec[0]->in,(fftwf_complex *) fftspec[0]->out, FFTW_FORWARD, FFTW_ESTIMATE); pthread_mutex_unlock(&FFTinitMutex); return vecNoErr;} // Always FORWARD inline vecStatus genericMove_32fc(cf32 *src,cf32 *dest, int len) { memmove(dest,src,len*sizeof(dest[0])); return vecNoErr;} inline vecStatus genericMove_32f(f32 *src,f32 *dest, int len) { memmove(dest,src,len*sizeof(dest[0])); return vecNoErr;} //{ for (int i=(len-1);i<=0;i--) dest[i]=src[i]; return vecNoErr;} // Does not guarentee not over writing inline vecStatus genericStdDev_32f(f32 *src, int len, f32 *stddev, vecHintAlg hint) { f32 sum; genericSum_32f(src,len,&sum); sum /= len; if (!len) sum=0; stddev[0]=0; for(int i=0;i1) stddev[0]=sqrt(stddev[0])/(len-1); return vecNoErr; } inline vecStatus genericAbs_32f_I(f32 *srcdest, int len) { for(int i=0;i0)? srcdest[i]:-srcdest[i];} return vecNoErr; } inline vecStatus genericMaxIndx_32f(f32 *src, int len, f32 *max, int *imax) { imax[0]=-1;max[0]=-1E30; for(int i=0;imax[0]) { max[0]=src[i];imax[0]=i;}} return vecNoErr; } //inline vecStatus genericZero_32s(s32 * dest, int length) { for(int i=0;iin); fftwf_free(fftspec->out); pthread_mutex_lock(&FFTinitMutex); fftwf_destroy_plan(fftspec->p); pthread_mutex_unlock(&FFTinitMutex); free(fftspec);return vecNoErr; } inline vecStatus genFreeFFTC_cf32(GenFFTPtrCfc32* fftspec) { fftwf_free(fftspec->in);fftwf_free(fftspec->out); pthread_mutex_lock(&FFTinitMutex); fftwf_destroy_plan(fftspec->p); pthread_mutex_unlock(&FFTinitMutex); free(fftspec); return vecNoErr; } inline vecStatus genFreeFFTCR_f32(GenFFTPtrCRf32* fftspec) { fftwf_free(fftspec->in); fftwf_free(fftspec->out); pthread_mutex_lock(&FFTinitMutex); fftwf_destroy_plan(fftspec->p); pthread_mutex_unlock(&FFTinitMutex); free(fftspec); return vecNoErr; } #define vectorFreeFFTR_f32(fftspec) genFreeFFTR_f32(fftspec) #define vectorFreeFFTC_cf32(fftspec) genFreeFFTC_cf32(fftspec) #define vectorFreeDFTC_cf32(fftspec) genFreeFFTC_cf32(fftspec) #define vectorFreeDFTR_f32(fftspec) genFreeFFTR_f32(fftspec) #define vectorFreeFFTCR_f32(fftspec) genFreeFFTCR_f32(fftspec) #define vectorFreeDFTCR_f32(fftspec) genFreeFFTCR_f32(fftspec) // I believe it is NEVER USED? /* #define vectorFreeFFTC_f32(fftspec) ippsFFTFree_C_32f(fftspec) */ // Should use memmove? Is the (len/2+1) copy working as expected? inline vecStatus genFFT_RtoC_f32(const f32* src,f32* dest, GenFFTPtrRf32*fftspec,u8 * fftbuffer) { memcpy(fftspec->in, src, fftspec->len*sizeof(f32)); fftwf_execute(fftspec->p); memcpy(dest, fftspec->out, (fftspec->len/2+1)*sizeof(cf32)); return vecNoErr; } inline vecStatus genFFT_CtoC_cf32(const cf32 *src, cf32 *dest, GenFFTPtrCfc32* fftspec, u8 *fftbuffer) { memcpy(fftspec->in, src, fftspec->len*sizeof(cf32)); fftwf_execute(fftspec->p); memcpy(dest, fftspec->out, fftspec->len*sizeof(cf32)); return vecNoErr; } inline vecStatus genFFT_CtoR_f32(const f32* src, f32* dest, GenFFTPtrRf32*fftspec,u8 * fftbuffer) { memcpy(fftspec->in, src, (fftspec->len/2+1)*sizeof(cf32)); fftwf_execute(fftspec->p); memcpy(dest, fftspec->out, fftspec->len*sizeof(f32)); return vecNoErr; } inline vecStatus gen2DFFT_CtoC_32fc(const cf32 *src, int sstp, cf32 *dest, int dstp, GenFFTPtrCfc32* fftspec, u8 *fftbuffer) { memcpy(fftspec->in, src, fftspec->len2*fftspec->len*sizeof(cf32)); // Does the plan know the step size ahead of time ??? fftwf_execute(fftspec->p); memcpy(dest, fftspec->out, fftspec->len2*fftspec->len*sizeof(cf32)); return vecNoErr; } #define vectorFFT_RtoC_f32(src, dest, fftspec, fftbuffer) genFFT_RtoC_f32(src, dest, fftspec, fftbuffer) #define vectorFFT_CtoC_cf32(src, dest, fftspec, fftbuffer) genFFT_CtoC_cf32(src, dest, fftspec, fftbuffer) #define vectorFFT_CtoR_f32(src, dest, fftspec, fftbuffer) genFFT_CtoR_f32(src, dest, fftspec, fftbuffer) #define vectorDFT_CtoC_cf32(src, dest, fftspec, fftbuffer) vectorFFT_CtoC_cf32(src, dest, fftspec, fftbuffer) #define vectorDFT_RtoC_f32(src, dest, fftspec, fftbuffer) vectorFFT_RtoC_f32(src, dest, fftspec, fftbuffer) #define vectorDFT_CtoR_f32(src, dest, fftspec, fftbuffer) vectorFFT_CtoR_f32(src, dest, fftspec, fftbuffer) #define vectorMove_cf32(src, dest, length) genericMove_32fc(src, dest, length) #define vectorMove_f32(src, dest, length) genericMove_32f(src, dest, length) #define vectorStdDev_f32(src, length, stddev, hint) genericStdDev_32f(src, length, stddev, hint) #define vectorAbs_f32_I(srcdest, length) genericAbs_32f_I(srcdest, length) #define vectorMaxIndx_f32(srcdest, length, max, imax) genericMaxIndx_32f(srcdest,length, max, imax) // For difx_monitor // Note 2D #define vector2DFFT_CtoC_cf32(src, sstp, dest, dstp, fftspec, fftbuff) gen2DFFT_CToC_32fc(src, sstp, dest, dstp, fftspec, fftbuff) #define vector2DFreeFFTC_cf32(fftspec) genFreeFFTC_32fc(fftspec) #define vector2DInitFFTC_cf32(fftspec, orderx, ordery, flag, hint) gen2DInitFFTC_32fc(fftspec, orderx, ordery, flag, hint) #define vectorDivC_cf32_I(val, srcdest, length) genericDivC_32fc_I(val, srcdest, length) #define vectorDivC_f32_I(val, srcdest, length) genericDivC_32f_I(val, srcdest, length) #define vectorSqrt_f32_I(srcdest, len) genericSqrt_32f_I(srcdest, len) #define vectorFFTInv_CCSToR_32f(src, dest,fftspec,buff) vectorFFT_CtoR_f32(src, dest,fftspec,buff) #endif /* Generic Architecture */ inline vecStatus genericSplitScaled_16s32f(const s16 *src, f32 **dest, int numchannels, int chanlen) { f32 scale = 2.0/((f32)MAX_S16-(f32)MIN_S16); for (int n=0;n