nspcvrt.h

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

/*   dst       - an output complex vector to store the cartesian coords;   */
/*   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,nspcbPolarToCart,(const float  *mag, const float  *phase,
                                  SCplx  *dst,       int     len))
    NSPAPI(void,nspzbPolarToCart,(const double *mag, const double *phase,
                                  DCplx  *dst,       int     len))

/* FUNCTION:                                                               */
/*   nsp<s,d>brPolarToCart                                                 */
/* DESCRIPTION:                                                            */
/*   Convert polar coordinate to cartesian. Output data are formed as      */
/*            two real vectors.                                            */
/* PARAMETERS:                                                             */
/*   mag       - an input vector containing the magnitude components;      */
/*   phase     - an input vector containing the phase components(in rad)); */
/*   dstReal   - an output complex vector to store the coordinates X;      */
/*   dstImag   - an output complex vector to store the coordinates Y;      */
/*   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,nspsbrPolarToCart,(const float *mag, const float  *phase,
                                   float *dstReal,   float  *dstImag,int len))
    NSPAPI(void,nspdbrPolarToCart,(const double *mag,const double *phase,
                                   double *dstReal,  double *dstImag,int len))

/*-------------------------------------------------------------------------*/
/*  bPowerSpectr, brPowerSpectr, bMag, brMag, bPhase, brPhase              */
/*                                                                         */
/* Compute the magnitude and phase of complex vector elements.             */
/*-------------------------------------------------------------------------*/
/* FUNCTION:                                                               */
/*   nsp<v,c,z>bMag                                                        */
/* DESCRIPTION:                                                            */
/*   Compute the magnitude of complex vector elements.                     */
/* PARAMETERS:                                                             */
/*   src       - an input complex vector                                   */
/*   mag       - an output vector to store the magnitude components;       */
/*   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,nspcbMag,(const SCplx *src,float  *mag,int length))
    NSPAPI(void,nspzbMag,(const DCplx *src,double *mag,int length))
    NSPAPI(void,nspvbMag,(const WCplx *src,short  *mag,int length,
                          int ScaleMode, int    *ScaleFactor))

/* FUNCTION:                                                               */
/*   nsp<w,s,d>brMag                                                       */
/* DESCRIPTION:                                                            */
/*   Compute the magnitude of complex data formed as two real vectors.     */
/* PARAMETERS:                                                             */
/*   srcReal   - an input vector containing a real part of complex data    */
/*   srcImag   - an input vector containing an imag. part of complex data  */
/*   mag       - an output vector to store the magnitude components;       */
/*   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,nspsbrMag,(const float  *srcReal,const float  *srcImag,
                           float  *mag,          int     length))
    NSPAPI(void,nspdbrMag,(const double *srcReal,const double *srcImag,
                           double *mag,          int     length))
    NSPAPI(void,nspwbrMag,(const short  *srcReal,const short  *srcImag,
                           short  *mag,          int     length,
                           int   ScaleMode,    int    *ScaleFactor))

/* FUNCTION:                                                               */
/*   nsp<v,c,z>bPhase                                                      */
/* DESCRIPTION:                                                            */
/*   Compute the phase (in radians) of complex vector elements.            */
/* PARAMETERS:                                                             */
/*   src       - an input complex vector                                   */
/*   phase     - an output vector to store the phase components;           */
/*   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,nspcbPhase,(const SCplx *src,float  *phase,int length))
    NSPAPI(void,nspzbPhase,(const DCplx *src,double *phase,int length))
    NSPAPI(void,nspvbPhase,(const WCplx *src,short  *phase,int length))

/* FUNCTION:                                                               */
/*   nsp<w,s,d>brPhase                                                     */
/* DESCRIPTION:                                                            */
/*   Compute the phase of complex data formed as two real vectors.         */
/* PARAMETERS:                                                             */
/*   srcReal   - an input vector containing a real part of complex data    */
/*   srcImag   - an input vector containing an imag. part of complex data  */
/*   phase     - an output vector to store the magnitude components;       */
/*   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,nspsbrPhase,(const float  *srcReal,const float *srcImag,
                             float  *phase,        int    length))
    NSPAPI(void,nspdbrPhase,(const double *srcReal,const double *srcImag,
                             double *phase,        int     length))
    NSPAPI(void,nspwbrPhase,(const short  *srcReal,const short *srcImag,
                             short  *phase,        int     length))

/*-------------------------------------------------------------------------*/
/*  bPowerSpectr, brPowerSpectr                                            */
/*                                                                         */
/* Compute the power spectrum of complex vector.                           */
/*-------------------------------------------------------------------------*/
/* FUNCTION:                                                               */
/*   nsp<v,c,z>bPowerSpectr                                                */
/* DESCRIPTION:                                                            */
/*   Compute the power spectrum of complex vector.                         */
/* PARAMETERS:                                                             */
/*   src       - an input complex vector                                   */
/*   mag       - an output vector to store the power spectrum components;  */
/*   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,nspcbPowerSpectr,(const SCplx *src,float  *spectr,int length))
    NSPAPI(void,nspzbPowerSpectr,(const DCplx *src,double *spectr,int length))
    NSPAPI(void,nspvbPowerSpectr,(const WCplx *src,short  *spectr,int length,
                                  int    ScaleMode,
                                  int   *ScaleFactor))

/* FUNCTION:                                                               */
/*   nsp<w,s,d>brPowerSpectr                                               */
/* DESCRIPTION:                                                            */
/*   Compute the power spectrum of complex data formed as two real vectors */
/* PARAMETERS:                                                             */
/*   srcReal   - an input vector containing a real part of complex data    */
/*   srcImag   - an input vector containing an imag. part of complex data  */
/*   mag       - an output vector to store the power spectrum components;  */
/*   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,nspsbrPowerSpectr,(const float  *srcReal,const float  *srcImag,
                                   float  *spectr,               int     length))
    NSPAPI(void,nspdbrPowerSpectr,(const double *srcReal,const double *srcImag,
                                   double *spectr,               int     length))
    NSPAPI(void,nspwbrPowerSpectr,(const short  *srcReal,const short  *srcImag,
                                   short  *spectr,       int     length,
                                   int   ScaleMode,    int    *ScaleFactor))

#endif                                 /*   _NSPCVRT_H                     */

#ifdef __cplusplus
}
#endif