nspcvrt.h

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

    NSPAPI(void,nspsbFloatToS31Fix,  (const float *src,long  *dst, int len,int flags))
    NSPAPI(void,nspsbFloatToS15Fix,  (const float *src,short *dst, int len,int flags))
    NSPAPI(void,nspsbFloatToS7Fix,   (const float *src,char  *dst, int len,int flags))
    NSPAPI(void,nspsbFloatToS1516Fix,(const float *src,long  *dst, int len,int flags))

    NSPAPI(void,nspdbFloatToS31Fix,  (const double *src,long  *dst,int len,int flags))
    NSPAPI(void,nspdbFloatToS15Fix,  (const double *src,short *dst,int len,int flags))
    NSPAPI(void,nspdbFloatToS7Fix,   (const double *src,char  *dst,int len,int flags))
    NSPAPI(void,nspdbFloatToS1516Fix,(const double *src,long  *dst,int len,int flags))

/* FUNCTION:                                                               */
/*   nsp<s,d>bS31FixToFloat                                                */
/*   nsp<s,d>bS15FixToFloat                                                */
/*   nsp<s,d>bS7FixToFloat                                                 */
/*   nsp<s,d>bS1516FixToFloat                                              */
/* DESCRIPTION:                                                            */
/*   Converts the fixed-point data in the input array and stores the       */
/*       results in the output array                                       */
/*  nsp?bS31FixToFloat() from format of S.31(a sign bit,31 fractional bits)*/
/*  nsp?bS15FixToFloat() from format of S.15(a sign bit,15 fractional bits)*/
/*  nsp?bS7FixToFloat()  from format of S.7 (a sign bit,7  fractional bits)*/
/*  nsp?bS1516FixToFloat() from format of S15.16                           */
/*                    (a sign bit, 15 integer bits, 16 fractional bits)    */
/* PARAMETERS:                                                             */
/*   src       - an input array to be converted;                           */
/*   dst       - an output array to store the result;                      */
/*   len       - a length of the arrays;                                   */
/*                                                                         */

    NSPAPI(void,nspsbS31FixToFloat,  (const long  *src, float  *dst, int len))
    NSPAPI(void,nspsbS15FixToFloat,  (const short *src, float  *dst, int len))
    NSPAPI(void,nspsbS7FixToFloat,   (const char  *src, float  *dst, int len))
    NSPAPI(void,nspsbS1516FixToFloat,(const long  *src, float  *dst, int len))
    NSPAPI(void,nspdbS31FixToFloat,  (const long  *src, double *dst, int len))
    NSPAPI(void,nspdbS15FixToFloat,  (const short *src, double *dst, int len))
    NSPAPI(void,nspdbS7FixToFloat,   (const char  *src, double *dst, int len))
    NSPAPI(void,nspdbS1516FixToFloat,(const long  *src, double *dst, int len))

/*-------------------------------------------------------------------------*/
/*  bReal, bImag, bCplxTo2Real, b2RealToCplx                               */
/*                                                                         */
/* Return the real and imaginary parts of complex vectors                  */
/* or construct complex vectors from real and imaginary components         */
/*-------------------------------------------------------------------------*/
/* FUNCTION:                                                               */
/*   nsp<v,c,z>bReal                                                       */
/* DESCRIPTION:                                                            */
/*   Return the real part of the coplex vector                             */
/* PARAMETERS:                                                             */
/*   src       - an input complex vector                                   */
/*   dst       - an output vector to store the real part;                  */
/*   len       - a length of the arrays;                                   */
/* ERRORS:                                                                 */
/*    1) Some of pointers to input or output data are NULL                 */
/*    2) The length of the arrays is less or equal zero                    */
/*  These errors are registered only if NSP_DEBUG is defined               */
/*                                                                         */
    NSPAPI(void,nspcbReal,(const SCplx *src,float  *dst,int length))
    NSPAPI(void,nspzbReal,(const DCplx *src,double *dst,int length))
    NSPAPI(void,nspvbReal,(const WCplx *src,short  *dst,int length))

/* FUNCTION:                                                               */
/*   nsp<v,c,z>bImag                                                       */
/* DESCRIPTION:                                                            */
/*   Return the imaginary part of the coplex vector                        */
/* PARAMETERS:                                                             */
/*   src       - an input complex vector                                   */
/*   dst       - an output vector to store the imaginary part;             */
/*   len       - a length of the arrays;                                   */
/* ERRORS:                                                                 */
/*    1) Some of pointers to input or output data are NULL                 */
/*    2) The length of the arrays is less or equal zero                    */
/*  These errors are registered only if NSP_DEBUG is defined               */
/*                                                                         */
    NSPAPI(void,nspcbImag,(const SCplx *src,float  *dst,int length))
    NSPAPI(void,nspzbImag,(const DCplx *src,double *dst,int length))
    NSPAPI(void,nspvbImag,(const WCplx *src,short  *dst,int length))

/* FUNCTION:                                                               */
/*   nsp<v,c,z>bCplxTo2Real                                                */
/* DESCRIPTION:                                                            */
/*   Return the real and imaginary parts of the coplex vector              */
/* PARAMETERS:                                                             */
/*   src       - an input complex vector                                   */
/*   dstReal   - an output vector to store the real part                   */
/*   dstImag   - an output vector to store the imaginary part;             */
/*   len       - a length of the arrays;                                   */
/*                                                                         */
    NSPAPI(void,nspcbCplxTo2Real,(const SCplx  *src,    float  *dstReal,
                                  float  *dstImag,int     length))
    NSPAPI(void,nspzbCplxTo2Real,(const DCplx  *src,    double *dstReal,
                                  double *dstImag,int     length))
    NSPAPI(void,nspvbCplxTo2Real,(const WCplx  *src,    short  *dstReal,
                                  short  *dstImag,int     length))

/* FUNCTION:                                                               */
/*   nsp<v,c,z>b2RealToCplx                                                */
/* DESCRIPTION:                                                            */
/*   Construct complex vector from real and imaginary components           */
/* PARAMETERS:                                                             */
/*   srcReal   - an input real component. May be NULL - a real part of the */
/*               output will be zero;                                      */
/*   srcImag   - an input imaginary component. May be NULL - an imaginary  */
/*               part of the output will be zero;                          */
/*   dst       - an output complex vector;                                 */
/*   len       - a length of the arrays;                                   */
/*                                                                         */
    NSPAPI(void,nspcb2RealToCplx,(const float  *srcReal,const float  *srcImag,
                                  SCplx  *dst,          int     length))
    NSPAPI(void,nspzb2RealToCplx,(const double *srcReal,const double *srcImag,
                                  DCplx  *dst,          int     length))
    NSPAPI(void,nspvb2RealToCplx,(const short  *srcReal,const short  *srcImag,
                                  WCplx  *dst,          int     length))

/*-------------------------------------------------------------------------*/
/*  bCartToPolar, brCartToPolar, bPolarToCart, brPolarToCart               */
/*                                                                         */
/* Cartesian to polar and polar to cartesian coordinate conversions.       */
/*-------------------------------------------------------------------------*/
/* FUNCTION:                                                               */
/*   nsp<v,c,z>bCartToPolar                                                */
/* DESCRIPTION:                                                            */
/*   Convert cartesian coordinate to polar. Input data are formed as       */
/*            a complex vector.                                            */
/* PARAMETERS:                                                             */
/*   src       - an input complex vector;                                  */
/*   mag       - an output vector to store the magnitude components;       */
/*   phase     - an output vector to store the phase components (in rad)); */
/*   len       - a length of the arrays;                                   */
/* ERRORS:                                                                 */
/*    1) Some of pointers to input or output data are NULL                 */
/*    2) The length of the arrays is less or equal zero                    */
/*  These errors are registered only if NSP_DEBUG is defined               */
/*                                                                         */
    NSPAPI(void,nspcbCartToPolar,(const SCplx *src, float  *mag, float  *phase,
                                  int    len))
    NSPAPI(void,nspzbCartToPolar,(const DCplx *src, double *mag, double *phase,
                                  int    len))

/* FUNCTION:                                                               */
/*   nsp<w,s,d>brCartToPolar                                               */
/* DESCRIPTION:                                                            */
/*   Convert cartesian coordinate to polar. Input data are formed as       */
/*            two different real vectors.                                  */
/* PARAMETERS:                                                             */
/*   srcReal   - an input vector containing the coordinates X;             */
/*   srcImag   - an input vector containing the coordinates Y;             */
/*   mag       - an output vector to store the magnitude components;       */
/*   phase     - an output vector to store the phase components (in rad)); */
/*   len       - a length of the arrays;                                   */
/* ERRORS:                                                                 */
/*    1) Some of pointers to input or output data are NULL                 */
/*    2) The length of the arrays is less or equal zero                    */
/*  These errors are registered only if NSP_DEBUG is defined               */
/*                                                                         */
    NSPAPI(void,nspsbrCartToPolar,(const float  *srcReal,const float  *srcImag,
                                   float  *mag,          float  *phase,
                                   int     len))
    NSPAPI(void,nspdbrCartToPolar,(const double *srcReal,const double *srcImag,
                                   double *mag,          double *phase,
                                   int     len))

/* FUNCTION:                                                               */
/*   nsp<v,c,z>bPolarToCart                                                */
/* DESCRIPTION:                                                            */
/*   Convert polar coordinate to cartesian. Output data are formed as      */
/*            a complex vector.                                            */
/* PARAMETERS:                                                             */
/*   mag       - an input vector containing the magnitude components;      */
/*   phase     - an input vector containing the phase components(in rad)); */