nsplmsl.h

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

/*M* 
//  
//               INTEL CORPORATION PROPRIETARY INFORMATION  
//  This software is supplied under the terms of a license agreement or  
//  nondisclosure agreement with Intel Corporation and may not be copied  
//  or disclosed except in accordance with the terms of that agreement.  
//        Copyright (c) 1996 Intel Corporation. All Rights Reserved.  
//  
//      $Workfile: nsplmsl.h $
//      $Revision: 4 $
//      $Modtime: 24.04.97 14:27 $
// 
//    Purpose: NSP Adaptive FIR filter that uses the LMS algorithm.
// 
*M*/ 
#ifdef __cplusplus
extern "C" {
#endif
#if !defined (_NSPLMSL_H) || defined (_OWN_BLDPCS)
   #define _NSPLMSL_H

   #if !defined (_NSPFIRL_H)
      #include "nspfirl.h"
   #endif

/* ------------------------------------------------------------------------*/

   #if !defined (_OWN_BLDPCS)

/* --- LMS filter (method) type -------------------------------------------*/

   typedef enum _NSPLmsType {
      NSP_LmsNull, NSP_LmsDefault
   } NSPLmsType;

/* --- LMS low-level filter state structure -------------------------------*/

   typedef struct _NSPLmsTapState {
      FirLmsTapState;                        /* Base filter state, see FIRL.H */
      float           leak;                  /* Leak value to range taps magn */
      float           step;                  /* Step-size to change taps magn */
      int             errDly;                /* Delay of error signal         */
      NSPLmsType      type;
   } NSPLmsTapState;

/* --- LMS low-level filter delay line ------------------------------------*/

   typedef struct _NSPLmsDlyState {
      FirLmsDlyState;
      int adaptB;                   /* Is used in delay length definition     */
   } NSPLmsDlyState;

/* ////////////////////////////////////////////////////////////
   LMSL of "integer" type uses Fixed Point representation of taps
//////////////////////////////////////////////////////////// */

   typedef int FixedPoint;

   typedef struct _NSPWLmsTapState {
      FirLmsTapState;               /* Base filter state, see FIRL.H   */
      float leak;                   /* Leak value to arrange taps magn */
      union {                       /* Step size to change taps values */
         float f;
         FixedPoint i;
      } step;
      int errDly;                   /* Delay of an error signal */
      NSPLmsType type;
   } NSPWLmsTapState;

   typedef NSPLmsDlyState NSPWLmsDlyState;

   #endif

/* ------------------------------------------------------------------------*/
/* LmslInit, LmslInitMr, LmslInitDlyl                                      */
/*                                                                         */
/* Initialize  an adaptive  FIR filter  that uses  the least  mean-square  */
/* (LMS) algorithm.                                                        */


/*--- Single-rate init ----------------------------------------------------*/

   NSPAPI(void,nspsLmslInit,(NSPLmsType lmsType, float *taps, int tapsLen,
                             float step, float leak,int errDly,NSPLmsTapState *tapStPtr))

   NSPAPI(void,nspdLmslInit,(NSPLmsType lmsType, double *taps, int tapsLen,
                             float step, float leak,int errDly,NSPLmsTapState *tapStPtr))

   NSPAPI(void,nspcLmslInit,(NSPLmsType lmsType, SCplx *taps, int tapsLen,
                             float step, float leak,int errDly,NSPLmsTapState *tapStPtr))

   NSPAPI(void,nspzLmslInit,(NSPLmsType lmsType, DCplx *taps, int tapsLen,
                             float step, float leak,int errDly,NSPLmsTapState *tapStPtr))


/*--- Multi-rate init -----------------------------------------------------*/

   NSPAPI(void,nspsLmslInitMr,(NSPLmsType lmsType, float *taps, int tapsLen,
                               float step, float leak, int errDly, int downFactor,
                               int downPhase, NSPLmsTapState *tapStPtr))

   NSPAPI(void,nspdLmslInitMr,(NSPLmsType lmsType, double *taps, int tapsLen,
                               float step, float leak, int errDly, int downFactor,
                               int downPhase, NSPLmsTapState *tapStPtr))

   NSPAPI(void,nspcLmslInitMr,(NSPLmsType lmsType, SCplx *taps, int tapsLen,
                               float step, float leak, int errDly, int downFactor,
                               int downPhase, NSPLmsTapState *tapStPtr))

   NSPAPI(void,nspzLmslInitMr,(NSPLmsType lmsType, DCplx *taps, int tapsLen,
                               float step, float leak, int errDly, int downFactor,
                               int downPhase, NSPLmsTapState *tapStPtr))

/*--- Delay line init -----------------------------------------------------*/

   NSPAPI(void,nspsLmslInitDlyl,(NSPLmsTapState *tapStPtr, float *dlyl, int adaptB,
                                 NSPLmsDlyState *dlyStPtr))

   NSPAPI(void,nspdLmslInitDlyl,(NSPLmsTapState *tapStPtr, double *dlyl,int adaptB,
                                 NSPLmsDlyState *dlyStPtr))

   NSPAPI(void,nspcLmslInitDlyl,(NSPLmsTapState *tapStPtr, SCplx *dlyl, int adaptB,
                                 NSPLmsDlyState *dlyStPtr))

   NSPAPI(void,nspzLmslInitDlyl,(NSPLmsTapState *tapStPtr, DCplx *dlyl, int adaptB,
                                 NSPLmsDlyState *dlyStPtr))

/* -------------------------------------------------------------------------*/
/* LmslGetStep, LmslSetStep, LmslGetLeak, LmslSetLeak                       */
/*                                                                          */
/* Utility  functions  to  get  and  set  the  leak  and step values of a   */
/* low-level LMS filter.                                                    */

   NSPAPI(float,nspsLmslGetStep, (const NSPLmsTapState *statePtr))
   NSPAPI(float,nspsLmslGetLeak, (const NSPLmsTapState *statePtr))

   NSPAPI(void, nspsLmslSetStep, (float step, NSPLmsTapState *statePtr))
   NSPAPI(void, nspsLmslSetLeak, (float leak, NSPLmsTapState *statePtr))


/* -------------------------------------------------------------------------*/
/* Lmsl, bLmsl                                                              */
/*                                                                          */
/* Filter samples through a low-level LMS filter.                           */

   NSPAPI(float, nspsLmsl, (NSPLmsTapState *tapStPtr,
                            NSPLmsDlyState *dlyStPtr, float  samp, float  err))
   NSPAPI(SCplx, nspcLmsl, (NSPLmsTapState *tapStPtr,
                            NSPLmsDlyState *dlyStPtr, SCplx  samp, SCplx  err))
   NSPAPI(double,nspdLmsl, (NSPLmsTapState *tapStPtr,
                            NSPLmsDlyState *dlyStPtr, double samp, double err))
   NSPAPI(DCplx, nspzLmsl, (NSPLmsTapState *tapStPtr,