nspfft.h

利用intel dsplib 库函数进行特定2FSK信号（需传导频）解调

/*                                                                          */
/* Multiply two vectors stored in RCPack format.                            */
/*                                                                          */
/* ------------------------------------------------------------------------ */

    NSPAPI(void,nspwMpyRCPack2,(const short *src,  short  *dst, int order,
                                int    scaleMode,         int *scaleFactor))

    NSPAPI(void,nspsMpyRCPack2,(const float  *src, float  *dst, int order))

    NSPAPI(void,nspdMpyRCPack2,(const double *src, double *dst, int order))


    NSPAPI(void,nspwMpyRCPack3,(const short  *srcA,const short  *srcB,short  *dst,
                                int     order,
                                int     scaleMode, int    *scaleFactor))

    NSPAPI(void,nspsMpyRCPack3,(const float  *srcA,const float  *srcB,float  *dst,
                                int     order))

    NSPAPI(void,nspdMpyRCPack3,(const double *srcA,const double *srcB,double *dst,
                                int     order))

/* ------------------------------------------------------------------------ */
/*                                                                          */
/*                        MpyRCPerm2, MpyRCPerm3                            */
/*                                                                          */
/* Multiply two vectors stored in RCPerm format.                            */
/*                                                                          */
/* ------------------------------------------------------------------------ */

    NSPAPI(void,nspwMpyRCPerm2,(const short  *src, short  *dst, int order,
                                int     scaleMode,        int *scaleFactor))

    NSPAPI(void,nspsMpyRCPerm2,(const float  *src, float  *dst, int order))

    NSPAPI(void,nspdMpyRCPerm2,(const double *src, double *dst, int order))


    NSPAPI(void,nspwMpyRCPerm3,(const short  *srcA,const short  *srcB,short  *dst,
                                int     order,
                                int     scaleMode, int    *scaleFactor))

    NSPAPI(void,nspsMpyRCPerm3,(const float  *srcA,const float  *srcB,float  *dst,
                                int     order))

    NSPAPI(void,nspdMpyRCPerm3,(const double *srcA,const double *srcB,double *dst,
                                int     order))
/* ------------------------------------------------------------------------ */
/*                                                                          */
/*                        RealFft,  RealFftNip                              */
/*                                                                          */
/* Compute the forward or inverse FFT of a real signal.                     */
/*                                                                          */
/* ------------------------------------------------------------------------ */

    NSPAPI(void,nspwRealFft,(short  *samps, int order,  int  flags,
                             int     scaleMode,         int *scaleFactor))

    NSPAPI(void,nspsRealFft,(float  *samps, int order,  int  flags))
    NSPAPI(void,nspdRealFft,(double *samps, int order,  int  flags))


    NSPAPI(void,nspwRealFftNip,(const short  *inSamps,  WCplx *outSamps,
                                int     order,    int    flags,
                                int     scaleMode,int   *scaleFactor))

    NSPAPI(void,nspsRealFftNip,(const float  *inSamps,  SCplx *outSamps,
                                int     order,    int    flags))

    NSPAPI(void,nspdRealFftNip,(const double *inSamps,  DCplx *outSamps,
                                int     order,    int    flags))

/* ------------------------------------------------------------------------ */
/*                                                                          */
/*                            CcsFft, CcsFftNip                             */
/*                                                                          */
/* Compute the  forward or inverse  FFT of a  complex conjugate-symmetric   */
/* (CCS) signal.                                                            */
/*                                                                          */
/* ------------------------------------------------------------------------ */

    NSPAPI(void,nspwCcsFft,(short  *samps, int order, int flags,
                            int     scaleMode,        int *scaleFactor))

    NSPAPI(void,nspsCcsFft,(float  *samps, int order, int flags))
    NSPAPI(void,nspdCcsFft,(double *samps, int order, int flags))


    NSPAPI(void,nspwCcsFftNip,(const WCplx *inSamps,  short *outSamps,
                               int    order,    int    flags,
                               int    scaleMode,int   *scaleFactor))

    NSPAPI(void,nspsCcsFftNip,(const SCplx *inSamps, float  *outSamps,
                               int    order,   int     flags))

    NSPAPI(void,nspdCcsFftNip,(const DCplx *inSamps, double *outSamps,
                               int    order,   int     flags))

/* ------------------------------------------------------------------------ */
/*                                                                          */
/*                    nsp?Real2Fft, nsp?Real2FftNip                         */
/*                                                                          */
/* Compute the forward or inverse FFT of two real signals.                  */
/*                                                                          */
/* ------------------------------------------------------------------------ */

    NSPAPI(void,nspwReal2Fft,(short *xSamps, short *ySamps, int order, int flags,
                              int scaleMode, int *scaleFactor))

    NSPAPI(void,nspsReal2Fft,(float *xSamps, float *ySamps, int order, int flags))

    NSPAPI(void,nspdReal2Fft,(double *xSamps, double *ySamps, int order, int flags))


    NSPAPI(void,nspwReal2FftNip,(const short *xInSamps, WCplx  *xOutSamps,
                                 const short *yInSamps, WCplx  *yOutSamps,
                                 int order, int flags,
                                 int scaleMode, int *scaleFactor))

    NSPAPI(void,nspsReal2FftNip,(const float *xInSamps, SCplx  *xOutSamps,
                                 const float *yInSamps, SCplx  *yOutSamps,
                                 int order, int flags))

    NSPAPI(void,nspdReal2FftNip,(const double *xInSamps, DCplx *xOutSamps,
                                 const double *yInSamps, DCplx *yOutSamps,
                                 int order, int flags))

/* ------------------------------------------------------------------------ */
/*                                                                          */
/*                    nsp?Ccs2Fft, nsp?Ccs2FftNip                           */
/*                                                                          */
/* Compute the forward or reverse  FFT of two complex conjugate-symmetric   */
/* (CCS) signals.                                                           */
/*                                                                          */
/* ------------------------------------------------------------------------ */

    NSPAPI(void,nspwCcs2Fft,(short  *xSamps, short  *ySamps, int order,int flags,
                             int     scaleMode, int *scaleFactor))

    NSPAPI(void,nspsCcs2Fft,(float  *xSamps, float  *ySamps, int order,int flags))

    NSPAPI(void,nspdCcs2Fft,(double *xSamps, double *ySamps, int order,int flags))


    NSPAPI(void,nspwCcs2FftNip,(const WCplx *xInSamps, short  *xOutSamps,
                                const WCplx *yInSamps, short  *yOutSamps,
                                int order, int flags,
                                int scaleMode, int *scaleFactor))

    NSPAPI(void,nspsCcs2FftNip,(const SCplx *xInSamps, float  *xOutSamps,
                                const SCplx *yInSamps, float  *yOutSamps,
                                int order, int flags))

    NSPAPI(void,nspdCcs2FftNip,(const DCplx *xInSamps, double *xOutSamps,
                                const DCplx *yInSamps, double *yOutSamps,
                                int order, int flags))

/* ======================================================================== */

#endif                                                         /* _NSPFFT_H */
#ifdef __cplusplus
}
#endif