nspiirl.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) 1995 Intel Corporation. All Rights Reserved.
//
//      $Workfile: nspiirl.h $
//      $Revision: 6 $
//      $Modtime: Dec 16 1996 18:31:26  $
//
//  Purpose: NSP Infinite Impulse Response Filtering.
*M*/
#ifdef __cplusplus
extern "C" {
#endif
#if !defined (_NSPIIRL_H) || defined (_OWN_BLDPCS)
   #define _NSPIIRL_H

   #if !defined (_OWN_BLDPCS)
/*---- User tap type ------------------------------------------------------*/

   typedef enum _NSPIirType {
      NSP_IirNull=0,
      NSP_IirDefault,
      NSP_IirUseTapsAsPtr
   } NSPIirType;

/*---- Implementation tap type of initialization --------------------------*/

   typedef enum _NSPIirInit {
      NSP_IirInit=0,
      NSP_IirXInit,
      NSP_IirInitBq,
      NSP_IirXInitBq
   }  NSPIirInit;

      #define MAX_IIR_FILTER 1024

/*---- IIR filter tap state structure -------------------------------------*/

   typedef struct _NSPIirTapState {
      int          order;                 /*  order/number of biquads        */
      void        *taps;                  /*  pointer to taps                */
      NSPIirType   iirtype;               /*  user type                      */
      NSPIirInit   initype;               /*  type of initialization         */
      int          tapsFactor;
   } NSPIirTapState;

/*---- IIR filter delay line state structure ------------------------------*/

   typedef struct _NSPIirDlyState {
      void        *dlyl;                  /*  pointer to delay line          */
   } NSPIirDlyState;

/*---- IIR filter state structure -----------------------------------------*/

   typedef struct _NSPIirState {
      NSPIirTapState  tapSt;              /* tap state structure             */
      NSPIirDlyState  dlySt;              /* delay line state structure      */
      int             init;               /* initialization flag             */
   } NSPIirState;

   #endif                                 /*_NSPIIRL_DEF                     */


/*-------------------------------------------------------------------------*/
/*         IirlInit, IirlInitBq, IirlInitDlyl                              */
/*                                                                         */
/* Perform infinite impulse response filtering.                            */
/*-------------------------------------------------------------------------*/
/* FUNCTION:                                                               */
/*   nsp<s,c,d,z>IirlInit                                                  */
/* DESCRIPTION:                                                            */
/*   Taps initialization of low-level arbitrary order IIR-filter with      */
/*   transfer function expressed as the ratio of two polinomials of order  */
/*   "order".                                                              */
/* PARAMETERS:                                                             */
/*   iirType  - input, determines the filter structure to use, currently   */
/*              must be NSP_IirDefault;                                    */
/*   taps     - input/output, sets the array taps of filter with transfer  */
/*              function                                                   */
/*                   B0+B1/z+B2/z/z ... +Border/z**order                   */
/*              H(z)=------------------------------------                  */
/*                   A0+A1/z+A2/z/z ... +Aorder/z**order                   */
/*              in following order:                                        */
/*                  B0, B1, ... Border,A0, A1, ... Aorder.                 */
/*              A0 must not be zero;                                       */
/*   order    - input, sets polinomial order;                              */
/*   tapStPtr - output, the pointer to the tap state structure.            */
/*                                                                         */
/*   gain - input, determines gain coefficient for filter output signal.   */
/*          It have to be positive value .                                 */
/*   InputRange - input, defines the bit range of input signal             */
/*                (from 4 to 16 bit). This gives possibility for the       */
/*                optimal taps recalculation from float to the internal    */
/*                short whith a fixed point flavor when input signal       */
/*                limitation is known.                                     */
/*    When gain = 1.0 and InputRange =16 the result of nspwIirlInitGain is */
/*    equal to nspwIirlInit.                                               */

   NSPAPI(void,nspwIirlInit,(NSPIirType      iirType, float  *taps, int order,
                             NSPIirTapState *tapStPtr))
   NSPAPI(void,nspwIirlInitGain,(NSPIirType      iirType, float  *taps, int order,
                                 NSPIirTapState *tapStPtr,  float gain,
                                 int InputRange))
   NSPAPI(void,nspsIirlInit,(NSPIirType      iirType, float  *taps, int order,
                             NSPIirTapState *tapStPtr))
   NSPAPI(void,nspcIirlInit,(NSPIirType      iirType, SCplx  *taps, int order,
                             NSPIirTapState *tapStPtr))
   NSPAPI(void,nspdIirlInit,(NSPIirType      iirType, double *taps, int order,
                             NSPIirTapState *tapStPtr))
   NSPAPI(void,nspzIirlInit,(NSPIirType      iirType, DCplx  *taps, int order,
                             NSPIirTapState *tapStPtr))

/*-------------------------------------------------------------------------*/
/* FUNCTION:                                                               */
/*   nsp<s,c,d,z>IirlInitBq                                                */
/* DESCRIPTION:                                                            */
/*   Low-level IIR-filter iinitialization taps to reference a cascade of   */
/*   biquads. Transfer function is a product of numQuads biquads.          */
/* PARAMETERS:                                                             */
/*   iirType  - input, determines the filter structure to use, currently   */
/*              must be NSP_IirDefault;                                    */
/*   taps     - input/output, sets the array taps of filter                */
/*              with the transfer function                                 */
/*                   (B10+B11/z+B12/z**2)* ... *(BnQ0+BnQ1/z+BnQ2/z**2)    */
/*              H(z)=--------------------------------------------------    */
/*                   (A10+A11/z+A12/z**2)* ... *(AnQ0+AnQ1/z+AnQ2/z**2)    */
/*              in following order:                                        */
/*                   B10, B11, B12, A10, A11, A12, ... ,                   */
/*                   BnQ0, BnQ1, BnQ2, AnQ0, AnQ1, AnQ2.                   */
/*              All Bi0 and Ai0 must not be zero;                          */
/*   numQuads - input, sets the number of biduads;                         */
/*   tapStPtr - output, pointer to the tap state structure.                */