winamp/Src/external_dependencies/intel_ipp_6.1.1.035/ia32/include/ippac.h

/*
//
//              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) 2001-2009 Intel Corporation. All Rights Reserved.
//
//          Intel(R) Integrated Performance Primitives
//                     Audio Coding (ippAC)
//
*/

#if !defined(__IPPAC_H__) || defined(_OWN_BLDPCS)
#define __IPPAC_H__

#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
  #define _IPP_STDCALL_CDECL
  #undef __stdcall
#endif

#include "ippdefs.h"


#ifdef __cplusplus
extern "C" {
#endif

/*
//  Data Structures and Macro
*/

#if !defined(_OWN_BLDPCS)

/*
//  FDP
*/

struct FDPState_32f;
typedef struct FDPState_32f IppsFDPState_32f;

/*
//  FIR Block
*/

struct FIRBlockState_32f;
typedef struct FIRBlockState_32f IppsFIRBlockState_32f;

/*
//  MDCT
*/

struct MDCTFwdSpec_32f;
typedef struct MDCTFwdSpec_32f IppsMDCTFwdSpec_32f;

struct MDCTInvSpec_32f;
typedef struct MDCTInvSpec_32f IppsMDCTInvSpec_32f;

struct MDCTFwdSpec_16s;
typedef struct MDCTFwdSpec_16s IppsMDCTFwdSpec_16s;

/*
//  Filter_SBR
*/

struct IppsFilterContext_SBR_32f;
typedef struct IppsFilterContext_SBR_32f IppsFilterSpec_SBR_C_32fc;
typedef struct IppsFilterContext_SBR_32f IppsFilterSpec_SBR_C_32f;
typedef struct IppsFilterContext_SBR_32f IppsFilterSpec_SBR_R_32f;

struct IppsFilterContext_SBR_32s;
typedef struct IppsFilterContext_SBR_32s IppsFilterSpec_SBR_C_32sc;
typedef struct IppsFilterContext_SBR_32s IppsFilterSpec_SBR_R_32s;

/*
//  Filter_PQMF
*/

struct IppsFilterContext_PQMF_MP3;
typedef struct IppsFilterContext_PQMF_MP3 IppsFilterSpec_PQMF_MP3;

/*
//  Filter_DTS
*/

struct IppsFilterContext_DTS_32f;
typedef struct IppsFilterContext_DTS_32f IppsFilterSpec_DTS_32f;

/*
//  MP3 codec defines
*/

#define IPP_MP3_GRANULE_LEN   576 /* maximum number of frequency
                                     decoded lines */
#define IPP_MP3_SF_BUF_LEN    40  /* scalefactor buffer length */
#define IPP_MP3_V_BUF_LEN     512 /* V data buffers length (32-bit words) */
#define IPP_MP3_ID_MPEG2      0   /* MPEG-2 frame identifier */
#define IPP_MP3_ID_MPEG1      1   /* MPEG-1 frame identifier */

/*
//  Scalefactor band table length for short block
*/

#define IPP_MP3_SFB_TABLE_LONG_LEN    138
typedef const Ipp16s IppMP3ScaleFactorBandTableLong[IPP_MP3_SFB_TABLE_LONG_LEN];

/*
//  Scalefactor band table length for long block
*/

#define IPP_MP3_SFB_TABLE_SHORT_LEN   84
typedef const Ipp16s IppMP3ScaleFactorBandTableShort[IPP_MP3_SFB_TABLE_SHORT_LEN];

/*
//  Mixed block partition table
*/

#define IPP_MP3_MBP_TABLE_LEN   12
typedef const Ipp16s IppMP3MixedBlockPartitionTable[IPP_MP3_MBP_TABLE_LEN];

/* Example mixed block partition table

    For mixed blocks only, this partition table informs
    the Huffman decoder of how many SFBs to count for region0.


IppMP3MixedBlockPartitionTable Modified_Mbp_Table =
{
    // MPEG-2
    // 22.050 kHz
    // Long block SFBs      Short block SFBs
        6,                  2,

    // MPEG-2
    // 24 kHz
    // Long block SFBs      Short block SFBs
        6,                  2,

    // MPEG-2
    // 16 kHz
    // Long block SFBs      Short block SFBs
        6,                  2,

    // MPEG-1
    // 44.1 kHz
    // Long block SFBs      Short block SFBs
        8,                  0,

    // MPEG-1
    // 48 kHz
    // Long block SFBs      Short block SFBs
        8,                  0,

    // MPEG-1
    // 32 kHz
    // Long block SFBs      Short block SFBs
        8,                  0
};

*/


typedef enum {
  IPPAC_DTS_NONPERFECT  = 0,
  IPPAC_DTS_PERFECT = 1
} IppAC_DTS_SYNTHESIS;


typedef enum {
  IPP_CDBK_UNKNOWN  = 0,
  IPP_CDBK_STANDARD = 1
} Ipp_Cdbk_VQ_Hint;


typedef enum {
  IPPAC_PS_CONF0 = 0,
  IPPAC_PS_CONF1 = 1,
  IPPAC_PS_CONF2 = 2,
  IPPAC_PS_CONF3 = 3,
  IPPAC_PS_CONF4 = 4

} IppAC_PS_DEC_ANALYSIS;

typedef struct CdbkState_VQ_32f IppsVQCodeBookState_32f;

/*
//  MPEG-1, MPEG-2 BC header, 32 bits.
//  See ISO/IEC 11172-3, sect 2.4.1.3, 2.4.2.3, 2.4.2.4
*/

typedef struct {
  int id;              /* ID: 1 - MPEG-1, 0 - MPEG-2              */
  int layer;           /* layer index: 0x3 - Layer I
                                       0x2 - Layer II
                                       0x1 - Layer III            */
  int protectionBit;   /* CRC flag 0: CRC on, 1: CRC off          */
  int bitRate;         /* bit rate index                          */
  int samplingFreq;    /* sampling frequency index                */
  int paddingBit;      /* padding flag:
                            0 - no padding,
                            1 - padding                           */
  int privateBit;      /* private_bit, no use                     */
  int mode;            /* mono/stereo select information          */
  int modeExt;         /* extension to mode                       */
  int copyright;       /* copyright or not:
                            0 - no,
                            1 - yes                               */
  int originalCopy;    /* original bitstream or copy:
                            0 - copy,
                            1 - original                          */
  int emphasis;        /* flag indicates the type of de-emphasis
                          that shall be used                      */
  int CRCWord;         /* CRC-check word                          */
} IppMP3FrameHeader;

/*
//  MP3 side information structure, for each granule.
//  Other info main_data_begin, private_bits, scfsi are not included
//  here.
//  Please refer to reference ISO/IEC 11172-3:1993, 2.4.1.7, 2.4.2.7.
//  ISO/IEC 13818-3:1998, 2.4.1.7 ).
*/

typedef struct {
  int  part23Len;       /* the number of bits for scale factors
                           and Huffman data                       */
  int  bigVals;         /* the half number of Huffman data whose
                           maximum amplitudes are greater than 1  */
  int  globGain;        /* the quantizer step size information    */
  int  sfCompress;      /* information to select the number of
                           bits used for the transmission of the
                           scale factors                          */
  int  winSwitch;       /* flag signals that the block uses an
                           other than normal window               */
  int  blockType;       /* flag indicates the window type         */
  int  mixedBlock;      /* flag indicates type of block:
                            0 - non mixed block,
                            1 - mixed block                       */
  int  pTableSelect[3]; /* Huffman table index for the 3 regions
                           in big-values field                    */
  int  pSubBlkGain[3];  /* gain offset from the global gain for
                           one subblock                           */
  int  reg0Cnt;         /* the number of scale factor bands at
                           the boundary of the first region of
                           the big-values field                   */
  int  reg1Cnt;         /* the number of scale factor bands at
                           the boundary of the second region of
                           the big-values field                   */
  int  preFlag;         /* flag of high frequency amplification   */
  int  sfScale;         /* scale to the scale factors             */
  int  cnt1TabSel;      /* Huffman table index for the count1
                           region of quadruples                   */
} IppMP3SideInfo;

/*
//  Global Macro Definitions for AAC codec
*/

#define IPP_AAC_ELT_NUM       16          /* maximum number of elements for
                                             one program */
#define IPP_AAC_CR_ID_LEN     9           /* copyright id length */
#define IPP_AAC_LFE_ELT_NUM   (1<<2)      /* maximum Low Frequency
                                             Enhance elements number for one
                                             program */
#define IPP_AAC_DATA_ELT_NUM  (1<<3)      /* maximum data elements number
                                             for one program */
#define IPP_AAC_COMMENTS_LEN  (1<<8)      /* maximum length of the comment
                                             field in bytes */
#define IPP_AAC_TAG_LEN       4           /* length of AAC data element tag */
#define IPP_AAC_MAX_SFB       51          /* maximum scalefactor band for all
                                             sampling frequencies */
#define IPP_AAC_GROUP_NUM_MAX 8           /* max groups number for one frame */
#define IPP_AAC_SF_MAX        60          /* max number of sfb in one window */
#define IPP_AAC_PRED_SFB_MAX  41          /* maximum prediction scalefactor
                                             bands number for one frame */
#define IPP_AAC_SF_LEN        120         /* scale factor buffer length */
#define IPP_AAC_TNS_FILT_MAX  8           /* maximum filters number for one
                                             frame */
#define ADIF_ID               0x41444946  /* ASCII-"ADIF" */

/*
//  ADIF Header
*/

typedef struct {
  Ipp32u ADIFId;              /* 32-bit, "ADIF" ASCII code        */
  int copyIdPres;             /* copy id flag:
                                  0 - off,
                                  1 - on                          */
  int originalCopy;           /* copyright bit:
                                  0 - no copyright on the coded
                                      bitstream,
                                  1 - copyright protected         */
  int home;                   /* original/home bit:
                                  0 - the bitstream is a copy,
                                  1 - the bitstream is an original*/
  int bitstreamType;          /* bitstream flag:
                                  0 - constant rate bitstream,
                                  1 - variable rate bitstream     */
  int bitRate;                /* bit rate; if 0, unkown bit rate  */
  int numPrgCfgElt;           /* number of program configure
                                 elements                         */
  int pADIFBufFullness[IPP_AAC_ELT_NUM];  /* buffer fullness      */
  Ipp8u pCopyId[IPP_AAC_CR_ID_LEN];       /* copy id              */
} IppAACADIFHeader;

/*
// AAC Program Config Element
*/

typedef struct {
  int eltInsTag;              /* element instance tag             */
  int profile;                /* profile index:
                                  0 - main,
                                  1 - Low Complexity,
                                  2 - Scaleable Sampling Rate,
                                  3 - reserved                    */
  int samplingRateIndex;      /* sampling rate index              */
  int numFrontElt;            /* number of front elements         */
  int numSideElt;             /* number of side elements          */
  int numBackElt;             /* number of back elements          */
  int numLfeElt;              /* number of LFE elements           */
  int numDataElt;             /* number of data elements          */
  int numValidCcElt;          /* number of coupling channel
                                  elements                        */
  int monoMixdownPres;        /* mono mixdown flag:
                                  0 - off,
                                  1 - on                          */
  int monoMixdownEltNum;      /* number of mono mixdown elements  */
  int stereoMixdownPres;      /* stereo mixdown flag:
                                  0 - off,
                                  1 - on                          */
  int stereoMixdownEltNum;    /* number of stereo mixdown
                                  elements                        */
  int matrixMixdownIdxPres;   /* matrix mixdown flag:
                                  0 - off,
                                  1 - on                          */
  int matrixMixdownIdx;       /* identifier of the surround
                                  mixdown coefficient             */
  int pseudoSurroundEnable;   /* pseudo surround:
                                  0 - off,
                                  1 - on                          */
  int pFrontIsCpe[IPP_AAC_ELT_NUM];     /* channel pair flag for
                                           front elements         */
  int pFrontTagSel[IPP_AAC_ELT_NUM];    /* instance tag for front
                                           elements               */
  int pSideIsCpe[IPP_AAC_ELT_NUM];      /* channel pair flag for
                                           side elements          */
  int pSideTagSel[IPP_AAC_ELT_NUM];     /* instance tag for side
                                           elements               */
  int pBackIsCpe[IPP_AAC_ELT_NUM];      /* channel pair flag for
                                           back elements          */
  int pBackTagSel[IPP_AAC_ELT_NUM];     /* instance tag for back
                                           elements               */
  int pLfeTagSel[IPP_AAC_LFE_ELT_NUM];  /* channel pair flag for
                                           LFE elements           */
  int pDataTagSel[IPP_AAC_DATA_ELT_NUM];  /* instance tag for data
                                             elements             */
  int pCceIsIndSw[IPP_AAC_ELT_NUM];     /* independent flag for
                                           coupling               */
                                        /* channel elements       */
  int pCceTagSel[IPP_AAC_ELT_NUM];      /* instance tag for coupling
                                           channel elements       */
  int numComBytes;                      /* number of comment field
                                           bytes                  */
  Ipp8s pComFieldData[IPP_AAC_COMMENTS_LEN]; /* the comment buffer
                                                field             */
} IppAACPrgCfgElt;

/*
//  MPEG-2 AAC ADTS frame header See ISO/IEC 13838-7, Table 6.5
*/

typedef struct {
  /* ADTS fixed header */
  int id;                   /* ID 1                               */
  int layer;                /* layer index:
                                0x3 - Layer I,
                                0x2 - Layer II,
                                0x1 - Layer III                   */
  int protectionBit;        /* CRC flag:
                                0 - CRC on,
                                1 - CRC off                       */
  int profile;              /* profile:
                                0 - MP,
                                1 - LP,
                                2 - SSR                           */
  int samplingRateIndex;    /* sampling frequency index           */
  int privateBit;           /* private_bit, no use                */
  int chConfig;             /* channel configuration              */
  int originalCopy;         /* copyright bit:
                                0 - no copyright on the coded
                                bitstream,
                                1 - copyright protected           */
  int home;                 /* original/home bit:
                                0 - the bitstream is a copy,
                                1 - the bitstream is an original  */
  int emphasis;             /* no in ISO/IEC 13818-7, but used    */
                            /* by ISO/IEC 14490-3                 */
  /* ADTS variable header */
  int cpRightIdBit;         /* copyright id bit                   */
  int cpRightIdStart;       /* copyright id start                 */
  int frameLen;             /* frame length in bytes              */
  int ADTSBufFullness;      /* buffer fullness                    */
  int numRawBlock;          /* n of raw data blocks in the frame  */
  /* ADTS CRC error check, 16bits */
  int CRCWord;              /* CRC-check word                     */
} IppAACADTSFrameHeader;

/*
//  Channel Pair Element Structure
*/

typedef struct {
  int commonWin;          /* common window flag:
                              0 - off,
                              1 - on                        */
  int msMaskPres;         /* MS stereo mask present flag    */
  Ipp8u ppMsMask[IPP_AAC_GROUP_NUM_MAX][IPP_AAC_SF_MAX];
                          /* MS stereo flag buffer for each
                             scalefactor band               */
} IppAACChanPairElt;

/*
//  Individual Channel Side Information Structure.
*/

typedef struct {
  /* unpacked from the bitstream */
  int icsReservedBit;     /* reserved bit                         */
  int winSequence;        /* window sequence flag                 */
  int winShape;           /* window shape flag:
                              0 - sine window,
                              1 - KBD window                      */
  int maxSfb;             /* maximum effective scale factor bands */
  int sfGrouping;         /* scale factor grouping information    */
  int predDataPres;       /* prediction data present flag for one
                             frame:
                              0 - prediction off,
                              1 - prediction on                   */
  int predReset;          /* prediction reset flag:
                              0 - off,
                              1 - on                              */
  int predResetGroupNum;  /* prediction reset group number        */
  Ipp8u pPredUsed[IPP_AAC_PRED_SFB_MAX+3];
                          /* prediction flag buffer for each scale
                             factor band:
                              0 - off,
                              1 - on buffer length 44 bytes, 4-byte
                                  align                           */
  /* decoded from the above info */
  int numWinGrp;          /* window group number                  */
  int pWinGrpLen[IPP_AAC_GROUP_NUM_MAX]; /* buffer for number of
                                            windows in each group */
} IppAACIcsInfo;

/*
//  MPEG 4 Layer
*/

#define IPP_AAC_TNS_COEF_LEN  60        /* TNS coefficients buffer length */
#define IPP_AAC_MAX_LTP_SFB   40        /* maximum length of Long Term
                                           Prediction buffer for long block */
#define IPP_AAC_WIN_MAX       8         /* maximum length of Long Term
                                           Prediction buffer for short block */
#define IPP_AAC_CHAN_NUM      2         /* number of AAC channels */
#define NOISE_HCB             13        /* code of HCB noise in scalefactor code book */
#define IPP_AAC_FRAME_LEN     1024      /* size of data in one AAC frame */
#define IPP_LTP_BLOCK_LEN     (1024*3)  /* size of data in one AAC LTP block */

/*
//  AAC Channel Information Structure
*/

typedef struct {
  int tag;               /* channel tag                           */
  int id;                /* element id                            */
  int samplingRateIndex; /* sampling rate index                   */
  int predSfbMax;        /* maximum prediction scale factor bands */
  int preWinShape;       /* previous block window shape           */
  int winLen;            /* 128: if short window, 1024: others    */
  int numWin;            /* 1 for long block, 8 for short block   */
  int numSwb;            /* decided by sampling frequency and
                            block type                            */
  /* unpacking from the bitstream */
  int globGain;          /* global gain                           */
  int pulseDataPres;     /* pulse data present flag:
                             0 - off,
                             1 - on                               */
  int tnsDataPres;       /* TNS data present flag:
                             0 - off,
                             1 - on                               */
  int gainContrDataPres; /* gain control data present flag:
                             0 - off,
                             1 - on                               */
  /* Ics Info pointer */
  IppAACIcsInfo *pIcsInfo;  /* pointer to IppAACIcsInfo structure */
  /* channel pair element pointer */
  IppAACChanPairElt *pChanPairElt; /* pointer to IppAACChanPairElt
                                      structure                   */
  /* section data */
  Ipp8u pSectCb[IPP_AAC_SF_LEN];   /* section code book buffer    */
  Ipp8u pSectEnd[IPP_AAC_SF_LEN];  /* end of scale factor offset
                                      in each section             */
  int pMaxSect[IPP_AAC_GROUP_NUM_MAX];  /* maximum section number
                                           for each group         */
  /* TNS data */
  int pTnsNumFilt[IPP_AAC_GROUP_NUM_MAX];   /* TNS number filter
                                               number buffer      */
  int pTnsFiltCoefRes[IPP_AAC_GROUP_NUM_MAX]; /* TNS coefficients
                                                 resolution flag  */
  int pTnsRegionLen[IPP_AAC_TNS_FILT_MAX];  /* TNS filter length  */
  int pTnsFiltOrder[IPP_AAC_TNS_FILT_MAX];  /* TNS filter order   */
  int pTnsDirection[IPP_AAC_TNS_FILT_MAX];  /* TNS filter direction
                                               flag               */
} IppAACChanInfo;

/*
//  TNS Information Structure
*/

typedef struct {
  int tnsDataPresent;                     /* if TNS is used       */
  int pTnsNumFilt[IPP_AAC_GROUP_NUM_MAX]; /* Number of TNS filter */
  int pTnsFiltCoefRes[IPP_AAC_GROUP_NUM_MAX]; /* TNS coefficient
                                                  resolution      */
  int pTnsRegionLen[IPP_AAC_TNS_FILT_MAX]; /* TNS filter length   */
  int pTnsFiltOrder[IPP_AAC_TNS_FILT_MAX]; /* TNS filter order    */
  int pTnsDirection[IPP_AAC_TNS_FILT_MAX]; /* TNS filter direction
                                              flag                */
  int pTnsCoefCompress[IPP_AAC_GROUP_NUM_MAX]; /* TNS compress
                                                  coefficients    */
  Ipp8s pTnsFiltCoef[IPP_AAC_TNS_COEF_LEN];    /* TNS filter
                                                  coefficients    */
} IppAACTnsInfo;

/*
//  Long Term Prediction (LTP) Structure
*/

typedef struct{
  int ltpDataPresent;             /* if LTP is used               */
  int ltpLag;                     /* optimal delay from 0 to 2047 */
  Ipp16s ltpCoef;                 /* indicate the LTP coefficient */
  int pLtpLongUsed[IPP_AAC_SF_MAX+1];   /* if long block use ltp  */
  int pLtpShortUsed[IPP_AAC_WIN_MAX];   /* if short block use ltp */
  int pLtpShortLagPresent[IPP_AAC_WIN_MAX]; /* if short lag
                                               is transmitted     */
  int pLtpShortLag[IPP_AAC_WIN_MAX];        /* relative delay
                                               for short window   */
} IppAACLtpInfo;

/*
//  AAC Scalable Main Element Header
*/

typedef struct {
  int windowSequence;  /* the windows is short or long type       */
  int windowShape;     /* what window is used for the right hand,
                          part of this analysis window            */
  int maxSfb;          /* number of scale factor band transmitted */
  int sfGrouping;      /* grouping of short spectral data         */
  int numWinGrp;       /* window group number                     */
  int pWinGrpLen[IPP_AAC_GROUP_NUM_MAX]; /* length of every group */
  int msMode;          /* MS stereo flag:
                           0 - none,
                           1 - different for every sfb,
                           2 - all                                */
  Ipp8u (*ppMsMask)[IPP_AAC_SF_MAX];  /* if MS's used in one sfb,
                                         when msMode == 1         */
  IppAACTnsInfo pTnsInfo[IPP_AAC_CHAN_NUM]; /* TNS structure for
                                               two channels       */
  IppAACLtpInfo pLtpInfo[IPP_AAC_CHAN_NUM]; /* LTP structure for
                                               two channels       */
} IppAACMainHeader;

/*
// AAC Scalable Extension Element Header
*/

typedef struct{
  int msMode;  /* Mode:
                   0 - non,
                   1 - part,
                   2 - all                                        */
  int maxSfb;  /* number of scale factor band for extension layer */
  Ipp8u (*ppMsMask)[IPP_AAC_SF_MAX];        /* if MS is used      */
  IppAACTnsInfo pTnsInfo[IPP_AAC_CHAN_NUM]; /* TNS structure
                                               for Stereo         */
  int pDiffControlLr[IPP_AAC_CHAN_NUM][IPP_AAC_MAX_SFB]; /*
                                       FSS information for stereo */
} IppAACExtHeader;

/*
//  MP3 encoder
*/

#define IPP_MP3_CHANNEL_NUM           2   /* Number MP3 channels */
#define IPP_MP3_PSY_BAND_LONG_NUM    63   /* Number MP3 partition energy for long blocks */
#define IPP_MP3_PSY_BAND_SHORT_NUM   42   /* Number MP3 partition energy for short blocks */
#define FIRST_6_CW                    6   /* Number calculated lines are used for
                                             unpredictability measure */
#define IPP_MP3_BIT_RATE_FREE         0   /* Type value for free bit rate */
#define IPP_MP3_BIT_RATE_32           1   /* Type value for 32 bit rate */
#define IPP_MP3_BIT_RATE_40           2   /* Type value for 40 bit rate */
#define IPP_MP3_BIT_RATE_48           3   /* Type value for 48 bit rate */
#define IPP_MP3_BIT_RATE_56           4   /* Type value for 56 bit rate */
#define IPP_MP3_BIT_RATE_64           5   /* Type value for 64 bit rate */
#define IPP_MP3_BIT_RATE_80           6   /* Type value for 80 bit rate */
#define IPP_MP3_BIT_RATE_96           7   /* Type value for 96 bit rate */
#define IPP_MP3_BIT_RATE_112          8   /* Type value for 112 bit rate */
#define IPP_MP3_BIT_RATE_128          9   /* Type value for 128 bit rate */
#define IPP_MP3_BIT_RATE_160         10   /* Type value for 160 bit rate */
#define IPP_MP3_BIT_RATE_192         11   /* Type value for 192 bit rate */
#define IPP_MP3_BIT_RATE_224         12   /* Type value for 224 bit rate */
#define IPP_MP3_BIT_RATE_256         13   /* Type value for 256 bit rate */
#define IPP_MP3_BIT_RATE_320         14   /* Type value for 320 bit rate */

#define IPP_MP3_SAMPLE_RATE_32000     2   /* Type value for 32000 sample rate */
#define IPP_MP3_SAMPLE_RATE_44100     0   /* Type value for 44100 sample rate */
#define IPP_MP3_SAMPLE_RATE_48000     1   /* Type value for 48000 sample rate */

#define IPP_MP3_NONINTERLEAVED_PCM    1   /* Type value for non interleaved PCM */
#define IPP_MP3_INTERLEAVED_PCM       2   /* Type value for interleaved PCM */

/*
//  MP3 Huffman Table Structure
*/

typedef struct {
  int         tableSize;      /* number of rows in table          */
  int         linbits;        /* variable used for encode if the
                                 magnitude of encoded value is
                                 greater or equal to 15           */
  int         maxBitsValue;   /* maximum bit length of codewords  */
  Ipp16u      *pHcod;         /* pointer to Huffman code table    */
  Ipp8u       *pSlen;         /* pointer to Huffman length table  */
} IppMP3HuffmanTable;

/*
//  MP3 Quant Information Structure
*/

typedef struct {
  int ScaleFactorBits;                /* number of bits used to
                                         encode scale factors     */
  Ipp32s pEnergy[IPP_MP3_SF_BUF_LEN]; /* energy of each scale
                                         factor band              */
  Ipp32s pDistortion[IPP_MP3_SF_BUF_LEN];  /* allowed distortion
                                              of each scale factor
                                              band                */
  Ipp32s pXmin[IPP_MP3_SF_BUF_LEN];   /* allowed distortion of
                                         each scale factor band   */
  Ipp32s pNMR[IPP_MP3_SF_BUF_LEN];    /* Noise-Mask-Ratio array   */
  int quantizeStepSize;               /* quantization step        */
  int pSfbMaxIndex[40];               /* index array of Scalefactor
                                         band maximum values      */
  int minBits;      /* minimum bits decided by the bit reservoir
                       and used bits                              */
  int maxBits;      /* decided by estimatedBits and bit reservoir */
  int count1;       /* number of Huffman symbols whose magnitude
                       is no greater than 1                       */
  int hufSize;      /* number of bits used for Huffman symbols    */
  int pRegionCount[3];  /* pointer to the number of Hufman symbols
                           in each region for the big values part */
} IppMP3QuantInfo;

/*
//  MP3 Bit Reservoir
*/

typedef struct {
  int BitsRemaining; /* bits currently remaining in the reservoir */
  int MaxBits; /* maximum possible reservoir size, in bits,
                  determined as follows:  min(7680-avg_frame_len,
                  2^9*8), where  avg_frame_len is the average frame
                  length, in bits, including padding bits and
                  excluding side information bits                 */
} IppMP3BitReservoir;

/*
//  Psychoacoustic Model Two State
*/

typedef struct {
  Ipp64s pPrevMaskedThresholdLong[2][63];    /* long block masked
             threshold history buffer; Contains masked threshold
             estimates for the threshold calculation partitions
             associated with the two most recent long blocks      */
  Ipp64s pPrevMaskedThresholdShort[IPP_MP3_PSY_BAND_SHORT_NUM]; /*
             short block masked threshold history buffer; Contains
             masked threshold estimates for the threshold
             calculation partitions associated with the two most
             recent long blocks                                   */
  Ipp32sc pPrevFFT[2][FIRST_6_CW];        /* FFT history buffer;
             contains real and imaginary FFT components associated
             with the two most recent long blocks                 */
  Ipp32s pPrevFFTMag[2][FIRST_6_CW];      /* FFT magnitude history
             buffer; contains FFT component magnitudes associated
             with the two most recent long blocks                 */
  int nextPerceptualEntropy;              /* PE estimate for next
             granule; one granule delay provided for synchronization
             with analysis filterbank                             */
  int nextBlockType;                     /* Expected block type for
             next granule; either long (normal), short, or stop.
             Depending upon analysis results for the granule
             following the next, a long block could change to a
             start block, and a stop block could change to a short
             block. This buffer provides one granule of delay for
             synchronization with the analysis filterbank         */
  Ipp32s pNextMSRLong[IPP_MP3_SF_BUF_LEN];        /* long block MSR
             estimates for next granule. One granule delay provided
             for synchronization with analysis filterbank         */
  Ipp32s pNextMSRShort[IPP_MP3_SF_BUF_LEN];       /* short block MSR
             estimates for next granule. One granule delay provided
             for synchronization with analysis filterbank         */
} IppMP3PsychoacousticModelTwoState;

/*
//  MP3 Psychoacoustic Model Two Analysis
*/

typedef struct {
  Ipp32s pMSR[36]; /* MSRs for one granule/channel. For long blocks,
                      elements 0-20 represent the thresholds
                      associated with the 21 SFBs. For short blocks,
                      elements 0,3,6,..,33, elements 1,4,...,34, and
                      elements 2,5,...,35, respectively, represent
                      the thresholds associated with the 12 SFBs for
                      each of the 3 consecutive short blocks in one
                      granule/channel. That is, the block thresholds
                      are interleaved such that the thresholds are
                      grouped by SFB.                             */
  Ipp32s PE;        /* Estimated perceptual entropy, one
                       granule/channel                            */
} IppMP3PsychoacousticModelTwoAnalysis;

#endif /* _OWN_BLDPCS */

/*******************************************************************/

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippacGetLibVersion
//
//  Purpose:
//    Get the library version.
//
//  Parameters:
//
//  Returns:
//    The structure of information about version of ippac library.
//
//  Notes:
//    Not necessary to release the returned structure.
*/
IPPAPI(const IppLibraryVersion*, ippacGetLibVersion, (void))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPReset_32f
//
//  Purpose:
//    Resets predictors for all spectral lines.
//
//  Parameters:
//    pFDPState             Pointer to the predictor specific state structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pFDPState pointer is
//                          NULL.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
*/
IPPAPI(IppStatus, ippsFDPReset_32f, (IppsFDPState_32f *pFDPState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPResetSfb_32f
//
//  Purpose:
//    Resets predictor-specific information in some scale factor bands.
//
//  Parameters:
//    pSfbOffset            Pointer to the band offset vector.
//    sfbNumber             Number of bands.
//    pResetFlag            Array of flags showing whether predictors for
//                          spectral lines in a certain scale factor band
//                          need to be reset. pFDPState Pointer to the
//                          predictor specific state structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsSizeErr         Indicates an error when sfbNumber is less than
//                          or equal to 0.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
*/
IPPAPI(IppStatus, ippsFDPResetSfb_32f, (const int* pSfbOffset, int sfbNumber, const Ipp8u* pResetFlag, IppsFDPState_32f* pFDPState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPResetGroup_32f
//
//  Purpose:
//    Resets predictors for group of spectral lines.
//
//  Parameters:
//    resetGroupNumber      Number of the group to be reset.
//    step                  Distance between two neighboring spectral lines
//                          in the group.
//    pFDPState             Pointer to the predictor specific state structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pFDPState pointer is
//                          NULL.
//    ippStsSizeErr         Indicates an error when resetGroupNumber or step
//                          is less than or equal to 0.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
*/
IPPAPI(IppStatus, ippsFDPResetGroup_32f, (int resetGroupNumber, int step, IppsFDPState_32f* pFDPState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPInitAlloc_32f
//
//  Purpose:
//    Creates and initializes predictor state.
//
//  Parameters:
//    ppFDPState            Pointer to pointer to the FDP state structure to
//                          be created.
//    len                   Number of spectral lines to be processed. Audio
//                          Coding Functions 10 10-29
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the ppFDPState pointer is
//                          NULL.
//    ippStsSizeErr         Indicates an error when the len is less than
//                          or equal to 0.
//    ippStsMemAllocErr     Indicates an error when no memory is allocated.
*/
IPPAPI(IppStatus, ippsFDPInitAlloc_32f, (IppsFDPState_32f** ppFDPState, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPFree_32f
//
//  Purpose:
//    Closes FDP state.
//
//  Parameters:
//    pFDPState             Pointer to the FDP state structure to be closed.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pFDPState pointer is
//                          NULL.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
*/
IPPAPI(IppStatus, ippsFDPFree_32f, (IppsFDPState_32f *pFDPState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPFwd_32f
//
//  Purpose:
//    Performs frequency domain prediction procedure and calculates
//    prediction error.
//
//  Parameters:
//    pSrc                  Pointer to the input data array.
//    pDst                  Pointer to the data array to be filled with
//                          prediction errors.
//    pFDPState             Pointer to the predictor specific state structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pFDPState pointer is
//                          NULL.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
//    ippStsMisalignedBuf   Indicates misaligned arrays. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsFDPFwd_32f, (const Ipp32f* pSrc, Ipp32f* pDst, IppsFDPState_32f* pFDPState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPInv_32f_I
//
//  Purpose:
//    Retrieves input signal from prediction error, using frequency domain
//    prediction procedure.
//
//  Parameters:
//    pSrcDst               Pointer to the input and output data array for
//                          the in-place operation.
//    pBandsOffset          Pointer to the band offset vector.
//    predictorBandsNumber  Number of scale factor bands.
//    pPredictionUsed       Pointer to array of flags showing whether
//                          prediction will be used in certain scale factor
//                          band.
//    pFDPState             Pointer to the predictor specific state structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsSizeErr         Indicates an error when predictorBandsNumber is
//                          less than or equal to 0.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
//    ippStsMisalignedBuf   Indicates misaligned arrays. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsFDPInv_32f_I, (Ipp32f* pSrcDst, const int* pBandOffset, int predictorBandsNumber, const Ipp8u* pPredictionUsed, IppsFDPState_32f* pFDPState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPInit_32f
//
//  Purpose:
//    Initializes predictor state.
//
//  Parameters:
//    ppFDPState            Pointer to pointer to the FDP state structure to
//                          be initialized.
//    len                   Number of spectral lines to be processed.
//    pMemSpec              Pointer to the area for FDP state structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppFDPState or pMemSpec
//                          is NULL.
//    ippStsSizeErr         Indicates an error when the len is less than
//                          or equal to 0.
*/
IPPAPI(IppStatus, ippsFDPInit_32f, (IppsFDPState_32f **ppFDPState, int len, Ipp8u *pMemSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFDPGetSize_32f
//
//  Purpose:
//    Gets size of FDP state structure.
//
//  Parameters:
//    len                   Number of spectral lines to be processed.
//    pSizeState            Address of size value in bytes of the frequency
//                          domain predictor state structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSizeState pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when the length is less than
//                          or equal to 0.
*/
IPPAPI(IppStatus, ippsFDPGetSize_32f, (int len, int *pSizeState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFIRBlockInitAlloc_32f
//
//  Purpose:
//    Initializes FIR block filter state.
//
//  Parameters:
//    pState                Pointer to the FIR block filter state structure
//                          to be created.
//    order                 Number of elements in the array containing the
//                          tap values.
//    len                   Number of input signals.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pointers to data
//                          arrays are null.
//    ippStsMemAllocErr     Indicates an error when no memory is allocated.
//    ippStsFIRLenErr       Indicates an error when order or len is less
//                          than or equal to 0.
*/
IPPAPI(IppStatus, ippsFIRBlockInitAlloc_32f,(IppsFIRBlockState_32f** pState,
int order, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFIRBlockFree_32f
//
//  Purpose:
//    Closes FIR block filter state.
//
//  Parameters:
//    pState                Pointer to the FIR block filter state structure
//                          to be closed.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pointers to data
//                          arrays are null.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
*/
IPPAPI(IppStatus, ippsFIRBlockFree_32f,(IppsFIRBlockState_32f* pState))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsFIRBlockOne_32f
//
//  Purpose:
//    Filters vector of samples through FIR block filter.
//
//  Parameters:
//    pSrc                  Pointer to the input vector of samples to be
//                          filtered.
//    pDst                  Pointer to the vector of filtered output samples.
//    pState                Pointer to the FIR filter state structure.
//    pTaps                 Pointer to the vector of filter taps.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the state structure is
//                          invalid.
//    ippStsMisalignedBuf   Indicates misaligned arrays. Supply aligned data
//                          for better performance.
//    ippStsFIRLenErr       Indicates an error when one of following conditions is true:
//                          1)pState->len is less than or equal to 0;
//                          2)pState->order is less than or equal to 0;
//                          3)pState->queue_end is less than 0;
//                          4)pState->queue_end is greater or equal to pState->order.
*/
IPPAPI(IppStatus, ippsFIRBlockOne_32f,(Ipp32f *pSrc, Ipp32f* pDst, IppsFIRBlockState_32f* pState, Ipp32f *pTaps))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdInitAlloc_32f
//
//  Purpose:
//    Create and initialize modified discrete cosine transform specification
//    structure.
//
//  Parameters:
//    ppMDCTSpec            Pointer to pointer to MDCT specification
//                          structure to be created.
//    len                   Number of samples in MDCT. Since this set of
//                          functions was designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and , where . These values
//                          are the only values that appear in audio coding.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the ppMDCTSpec pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
//    ippStsMemAllocErr     Indicates an error when no memory is allocated.
*/
IPPAPI(IppStatus, ippsMDCTFwdInitAlloc_32f,(IppsMDCTFwdSpec_32f** ppMDCTSpec, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInvInitAlloc_32f
//
//  Purpose:
//    Create and initialize modified discrete cosine transform specification
//    structure.
//
//  Parameters:
//    ppMDCTSpec            Pointer to pointer to MDCT specification
//                          structure to be created.
//    len                   Number of samples in MDCT. Since this set of
//                          functions was designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and , where . These values
//                          are the only values that appear in audio coding.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the ppMDCTSpec pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
//    ippStsMemAllocErr     Indicates an error when no memory is allocated.
*/
IPPAPI(IppStatus, ippsMDCTInvInitAlloc_32f,(IppsMDCTInvSpec_32f** ppMDCTSpec, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdFree_32f
//
//  Purpose:
//    Closes modified discrete cosine transform specification structure.
//
//  Parameters:
//    pMDCTSpec             Pointer to the MDCT specification structure to
//                          be closed.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pMDCTSpec pointer is
//                          NULL.
*/
IPPAPI(IppStatus, ippsMDCTFwdFree_32f,(IppsMDCTFwdSpec_32f* pMDCTSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInvFree_32f
//
//  Purpose:
//    Closes modified discrete cosine transform specification structure.
//
//  Parameters:
//    pMDCTSpec             Pointer to the MDCT specification structure to
//                          be closed.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pMDCTSpec pointer is
//                          NULL.
*/
IPPAPI(IppStatus, ippsMDCTInvFree_32f,(IppsMDCTInvSpec_32f* pMDCTSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdGetBufSize_32f
//
//  Purpose:
//    Gets the size of MDCT work buffer.
//
//  Parameters:
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    pSize                 Address of the MDCT work buffer size value in
//                          bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pMDCTSpec pointer or
//                          pSize value is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
*/
IPPAPI(IppStatus, ippsMDCTFwdGetBufSize_32f,(const IppsMDCTFwdSpec_32f* pMDCTSpec,
    int* pSize))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInvGetBufSize_32f
//
//  Purpose:
//    Gets the size of MDCT work buffer.
//
//  Parameters:
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    pSize                 Address of the MDCT work buffer size value in
//                          bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pMDCTSpec pointer or
//                          pSize value is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
*/
IPPAPI(IppStatus, ippsMDCTInvGetBufSize_32f,(const IppsMDCTInvSpec_32f* pMDCTSpec,
    int* pSize))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwd_32f
//
//  Purpose:
//    Computes forward or inverse modified discrete cosine transform (MDCT)
//    of a signal.
//
//  Parameters:
//    pSrc                  Pointer to the input data array.
//    pDst                  Pointer to the output data array.
//    pSrcDst               Pointer to the input and output data array for
//                          the in-place operations.
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    pBuffer               Pointer to the MDCT work buffer.
//    scaleFactor           Scalefactor value.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsMDCTFwd_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
    const IppsMDCTFwdSpec_32f* pMDCTSpec, Ipp8u* pBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInv_32f
//
//  Purpose:
//    Computes forward or inverse modified discrete cosine transform (MDCT)
//    of a signal.
//
//  Parameters:
//    pSrc                  Pointer to the input data array.
//    pDst                  Pointer to the output data array.
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    pBuffer               Pointer to the MDCT work buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsMDCTInv_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
    const IppsMDCTInvSpec_32f* pMDCTSpec, Ipp8u* pBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwd_32f_I
//
//  Purpose:
//    Computes forward or inverse modified discrete cosine transform (MDCT)
//    of a signal.
//
//  Parameters:
//    pSrcDst               Pointer to the input and output data array for
//                          the in-place operations.
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    pBuffer               Pointer to the MDCT work buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsMDCTFwd_32f_I,(Ipp32f* pSrcDst, const IppsMDCTFwdSpec_32f* pMDCTSpec, Ipp8u* pBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInv_32f_I
//
//  Purpose:
//    Computes forward or inverse modified discrete cosine transform (MDCT)
//    of a signal.
//
//  Parameters:
//    pSrcDst               Pointer to the input and output data array for
//                          the in-place operations.
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    pBuffer               Pointer to the MDCT work buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsMDCTInv_32f_I,(Ipp32f* pSrcDst, const IppsMDCTInvSpec_32f* pMDCTSpec, Ipp8u* pBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwd_16s_Sfs
//
//  Purpose:
//    Computes forward or inverse modified discrete cosine transform (MDCT)
//    of a signal.
//
//  Parameters:
//    pSrc                  Pointer to the input data array.
//    pDst                  Pointer to the output data array.
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    scaleFactor           Scalefactor value.
//    pBuffer               Pointer to the MDCT work buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsMDCTFwd_16s_Sfs,
       (const Ipp16s *pSrc, Ipp16s *pDst,
        const IppsMDCTFwdSpec_16s* pMDCTSpec,
        int scaleFactor, Ipp8u* pBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdInitAlloc_16s
//
//  Purpose:
//    Create and initialize modified discrete cosine transform specification
//    structure.
//
//  Parameters:
//    ppMDCTSpec            Pointer to pointer to MDCT specification
//                          structure to be created.
//    len                   Number of samples in MDCT. Since this set of
//                          functions was designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and 2**k, where k>=5. These
//                          values are the only values that appear in audio
//                          coding.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the ppMDCTSpec pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
//    ippStsMemAllocErr     Indicates an error when no memory is allocated.
*/
IPPAPI(IppStatus, ippsMDCTFwdInitAlloc_16s, (IppsMDCTFwdSpec_16s** ppMDCTSpec, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdFree_32f
//
//  Purpose:
//    Closes modified discrete cosine transform specification structure.
//
//  Parameters:
//    pMDCTSpec             Pointer to the MDCT specification structure to
//                          be closed.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pMDCTSpec pointer is
//                          NULL.
*/
IPPAPI(IppStatus, ippsMDCTFwdFree_16s, (IppsMDCTFwdSpec_16s* pMDCTSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdGetSize_16s
//
//  Purpose:
//    Get the sizes of MDCT specification structure, MDCT initialization,
//    and MDCT work buffer.
//
//  Parameters:
//    len                   Number of samples in MDCT. Since this set of
//                          functions is designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and 2**k, where k>=5. These
//                          values are the only values that appear in audio
//                          coding.
//    pSizeSpec             Address of the MDCT specification structure size
//                          value in bytes.
//    pSizeInit             Address of the MDCT initialization buffer size
//                          value in bytes.
//    pSizeBuf              Address of the MDCT work buffer size value in
//                          bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSizeSpec,
//                          pSizeInit, or pSizeBuf pointer is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
*/
IPPAPI(IppStatus, ippsMDCTFwdGetSize_16s, (int len, int* pSizeSpec, int* pSizeInit, int* pSizeBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdGetBufSize_16s
//
//  Purpose:
//    Gets the size of MDCT work buffer.
//
//  Parameters:
//    pMDCTSpec             Pointer to the MDCT specification structure.
//    pSize                 Address of the MDCT work buffer size value in
//                          bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pMDCTSpec pointer or
//                          pSize value is NULL.
//    ippStsContextMatchErr Indicates an error when the specification
//                          structure pMDCTSpec is invalid.
*/
IPPAPI(IppStatus, ippsMDCTFwdGetBufSize_16s,
       (const IppsMDCTFwdSpec_16s *pMDCTSpec, int *pSize))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInvGetSize_32f
//
//  Purpose:
//    Get the sizes of MDCT specification structure, MDCT initialization,
//    and MDCT work buffer.
//
//  Parameters:
//    len                   Number of samples in MDCT. Since this set of
//                          functions is designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and 2**k, where k>=5. These
//                          values are the only values that appear in audio
//                          coding.
//    pSizeSpec             Address of the MDCT specification structure size
//                          value in bytes.
//    pSizeInit             Address of the MDCT initialization buffer size
//                          value in bytes.
//    pSizeBuf              Address of the MDCT work buffer size value in
//                          bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSizeSpec,
//                          pSizeInit, or pSizeBuf pointer is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
*/
IPPAPI(IppStatus, ippsMDCTInvGetSize_32f, (int len, int *pSizeSpec, int *pSizeInit, int *pSizeBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdGetSize_32f
//
//  Purpose:
//    Get the sizes of MDCT specification structure, MDCT initialization,
//    and MDCT work buffer.
//
//  Parameters:
//    len                   Number of samples in MDCT. Since this set of
//                          functions is designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and 2**k, where k>=5. These
//                          values are the only values that appear in audio
//                          coding.
//    pSizeSpec             Address of the MDCT specification structure size
//                          value in bytes.
//    pSizeInit             Address of the MDCT initialization buffer size
//                          value in bytes.
//    pSizeBuf              Address of the MDCT work buffer size value in
//                          bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSizeSpec,
//                          pSizeInit, or pSizeBuf pointer is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
*/
IPPAPI(IppStatus, ippsMDCTFwdGetSize_32f, (int len, int *pSizeSpec, int *pSizeInit, int *pSizeBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdInit_32f
//
//  Purpose:
//    Initialize modified discrete cosine transform specification structure.
//
//  Parameters:
//    ppMDCTSpec            Pointer to pointer to MDCT specification
//                          structure to be created.
//    len                   Number of samples in MDCT. Since this set of
//                          functions was designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and 2**k, where k>=5. These
//                          values are the only values that appear in audio
//                          coding.
//    pMemSpec              Pointer to the area for MDCT specification
//                          structure.
//    pMemInit              Pointer to the buffer that is used for
//                          initialization.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the ppMDCTSpec, pMemSpec
//                          or pMemInit pointer is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
*/
IPPAPI(IppStatus, ippsMDCTFwdInit_32f, (IppsMDCTFwdSpec_32f** ppMDCTSpec, int len, Ipp8u* pMemSpec, Ipp8u* pMemInit))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInvInit_32f
//
//  Purpose:
//    Initialize modified discrete cosine transform specification structure.
//
//  Parameters:
//    ppMDCTSpec            Pointer to pointer to MDCT specification
//                          structure to be created.
//    len                   Number of samples in MDCT. Since this set of
//                          functions was designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and 2**k, where k>=5. These
//                          values are the only values that appear in audio
//                          coding.
//    pMemSpec              Pointer to the area for MDCT specification
//                          structure.
//    pMemInit              Pointer to the buffer that is used for
//                          initialization.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the ppMDCTSpec, pMemSpec
//                          or pMemInit pointer is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
*/
IPPAPI(IppStatus, ippsMDCTInvInit_32f,(IppsMDCTInvSpec_32f** ppMDCTSpec, int len, Ipp8u* pMemSpec, Ipp8u* pMemInit))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwdInit_16s
//
//  Purpose:
//    Initialize modified discrete cosine transform specification structure.
//
//  Parameters:
//    ppMDCTSpec            Pointer to pointer to MDCT specification
//                          structure to be created.
//    len                   Number of samples in MDCT. Since this set of
//                          functions was designed specially for audio
//                          coding, only the following values of length are
//                          supported: 12, 36, and 2**k, where k>=5. These
//                          values are the only values that appear in audio
//                          coding.
//    pMemSpec              Pointer to the area for MDCT specification
//                          structure.
//    pMemInit              Pointer to the buffer that is used for
//                          initialization.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the ppMDCTSpec, pMemSpec
//                          or pMemInit pointer is NULL.
//    ippStsSizeErr         Indicates an error when len does not belong to
//                          the above set of admissible values.
*/
IPPAPI(IppStatus, ippsMDCTFwdInit_16s,(IppsMDCTFwdSpec_16s** ppMDCTSpec, int len, Ipp8u* pMemSpec, Ipp8u* pMemInit))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSpread_16s_Sfs
//
//  Purpose:
//    Computes spreading function.
//
//  Parameters:
//    Src1                  Input data 1.
//    Src2                  Input data 2.
//    inScaleFactor         Input value scalefactor value.
//    pDst                  Pointer to the output data vector, output data
//                          is in Q15 format.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pDst pointer is NULL.
*/
IPPAPI(IppStatus, ippsSpread_16s_Sfs,
      (Ipp16s src1, Ipp16s src2, int inScaleFactor, Ipp16s* pDst))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsInterleave_16s
//
//  Purpose:
//    Converts signal from non-interleaved to interleaved format.
//
//  Parameters:
//    pSrc                  Array of pointers to the vectors [len]
//                          containing samples for particular channels.
//    ch_num                Number of channels.
//    len                   Number of samples in each channel.
//    pDst                  Pointer to the destination vector [ch_num * len]
//                          in interleaved format.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len is less than or
//                          equal to 0.
//    ippStsNumChannelsErr  Indicates an error when ch_num is less than or
//                          equal to 0.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsInterleave_16s, (const Ipp16s   **pSrc,
                                             int      ch_num,
                                             int      len,
                                             Ipp16s   *pDst))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsInterleave_32f
//
//  Purpose:
//    Converts signal from non-interleaved to interleaved format.
//
//  Parameters:
//    pSrc                  Array of pointers to the vectors [len]
//                          containing samples for particular channels.
//    ch_num                Number of channels.
//    len                   Number of samples in each channel.
//    pDst                  Pointer to the destination vector [ch_num * len]
//                          in interleaved format.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len is less than or
//                          equal to 0.
//    ippStsNumChannelsErr  Indicates an error when ch_num is less than or
//                          equal to 0.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsInterleave_32f, (const Ipp32f **pSrc,
                                             int    ch_num,
                                             int    len,
                                             Ipp32f *pDst))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDeinterleave_16s
//
//  Purpose:
//    Converts signal from interleaved to non-interleaved format.
//
//  Parameters:
//    pSrc                  Pointer to vector [ch_num * len] of interleaved
//                          samples.
//    ch_num                Number of channels.
//    len                   Number of samples in each channel.
//    pDst                  Array of pointers to the vectors [len] to be
//                          filled with samples of particular channels.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len or ch_num is less
//                          than or equal to 0.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsDeinterleave_16s, (const Ipp16s* pSrc, int ch_num,
                                              int len, Ipp16s** pDst))
/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDeinterleave_32f
//
//  Purpose:
//    Converts signal from interleaved to non-interleaved format.
//
//  Parameters:
//    pSrc                  Pointer to vector [ch_num * len] of interleaved
//                          samples.
//    ch_num                Number of channels.
//    len                   Number of samples in each channel.
//    pDst                  Array of pointers to the vectors [len] to be
//                          filled with samples of particular channels.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len or ch_num is less
//                          than or equal to 0.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
*/
IPPAPI(IppStatus, ippsDeinterleave_32f, (const Ipp32f* pSrc, int ch_num,
                                              int len, Ipp32f** pDst))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPow34_32f16s
//
//  Purpose:
//    Raises a vector to the power of 3/4.
//
//  Parameters:
//    pSrc                  Pointer to the input data vector [len].
//    pDst                  Pointer to the output data vector [len].
//    len                   Number of elements in the input and output
//                          vectors.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
//    ippStsSizeErr         Indicates an error when len is less than or
//                          equal to 0.
*/
IPPAPI(IppStatus, ippsPow34_32f16s, (const Ipp32f* pSrc, Ipp16s* pDst, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPow43_16s32f
//
//  Purpose:
//    Raises a vector to the power of 4/3.
//
//  Parameters:
//    pSrc                  Pointer to the input data vector [len].
//    pDst                  Pointer to the output data vector [len].
//    len                   Number of elements in the input and output
//                          vectors.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data for
//                          better performance.
//    ippStsSizeErr         Indicates an error when len is less than or
//                          equal to 0.
*/
IPPAPI(IppStatus, ippsPow43_16s32f, (const Ipp16s* pSrc, Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsPow43Scale_16s32s_Sf, (const Ipp16s* pSrc, Ipp32s* pDst,
       const Ipp16s *pScaleFactor, const Ipp32s *pBandOffset,
       int offset, int bandsNumber, int groupLen, int scalef))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPow34_32f
//
//  Purpose:
//    Raises a vector to the power of 3/4.
//
//  Parameters:
//    pSrc                  Pointer to the input data vector [len].
//    pDst                  Pointer to the output data vector [len].
//    len                   Number of elements in the input and output
//                          vectors.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
//    ippStsSizeErr         Indicates an error when len is less than or
//                          equal to 0.
*/
IPPAPI(IppStatus, ippsPow34_32f,(const Ipp32f* pSrc, Ipp32f* pDst, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPow34_16s_Sfs
//
//  Purpose:
//    Raises a vector to the power of 3/4.
//
//  Parameters:
//    pSrc                  Pointer to the input data vector [len].
//    inscaleFactor         Input data scalefactor value.
//    pDst                  Pointer to the output data vector [len].
//    scaleFactor           Scalefactor value.
//    len                   Number of elements in the input and output
//                          vectors.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsMisalignedBuf   Indicates misaligned data. Supply aligned data
//                          for better performance.
//    ippStsSizeErr         Indicates an error when len is less than or
//                          equal to 0.
*/
IPPAPI(IppStatus, ippsPow34_16s_Sfs,(const Ipp16s* pSrc, int inScaleFactor, Ipp16s* pDst, int ScaleFactor, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsCalcSF_16s32f
//
//  Purpose:
//    Restores actual scale factors from the bit stream values.
//
//  Parameters:
//    pSrc                  Pointer to the input data array.
//    offset                Scale factors offset.
//    pDst                  Pointer to the output data array.
//    len                   Number of elements in the vector.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrc or pDst pointer
//                          is NULL.
//    ippStsSizeErr         Indicates an error when len is less than or
//                          equal to 0.
*/
IPPAPI(IppStatus,ippsCalcSF_16s32f, (const Ipp16s* pSrc, int offset,Ipp32f *pDst, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsScale_32f_I
//
//  Purpose:
//    Applies scale factors to spectral bands in accordance with spectral
//    bands boundaries.
//
//  Parameters:
//    pSrcDst               Pointer to the input and output data array. The
//                          size of array must be not less than pBandOffset[
//                          bands_number].
//    pSF                   Pointer to the data array containing scale
//                          factors. The size of the array must be not less
//                          than bands_number.
//    pBandOffset           Pointer to the vector of band offsets. The size
//                          of array must be not less than bands_number + 1.
//    bandsNumber           Number of bands to which scale factors are
//                          applied.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pSrcDst or
//                          pBandsOffset pointer is NULL.
//    ippStsSizeErr         Indicates an error when bandsNumber is less than
//                          or equal to 0.
*/
IPPAPI(IppStatus, ippsScale_32f_I, (Ipp32f* pSrcDst, Ipp32f* pSF, const Ipp32s* pBandOffset, int bandsNumber))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMakeFloat_16s32f
//
//  Purpose:
//    Converts mantissa and exponent arrays to float arrays.
//
//  Parameters:
//    inmant                Array of mantissas.
//    inexp                 Array of exponents.
//    size                  Number of array elements.
//    outfloat              Array of resulting float arrays.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the inmant, inexp or
//                          outfloat pointer is NULL.
//    ippStsSizeErr         Indicates an error when size is less than or
//                          equal to 0.
*/
IPPAPI(IppStatus, ippsMakeFloat_16s32f, (Ipp16s* inmant, Ipp16s* inexp, Ipp32s size, Ipp32f* outfloat))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQCodeBookInitAlloc_32f
//
//  Purpose:
//    Creates and initializes the codebook structure.
//
//  Parameters:
//    pInputTable           Pointer to the codebook table of the size step *
//                          height containing height quantization vectors of
//                          the length step.
//    ppCodeBook            Pointer to pointer to the codebook structure to
//                          be created.
//    step                  Step to the next line in the table InputTable,
//                          quantization vector length.
//    height                Table height, number of quantization vectors.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppCodeBook or
//                          pInputTable pointer is NULL.
//    ippStsSizeErr         Indicates an error when the step or height is
//                          less than or equal to 0.
//    ippStsMemAllocErr     Indicates an error when no memory is allocated.
*/
IPPAPI(IppStatus, ippsVQCodeBookInitAlloc_32f, (const Ipp32f* pInputTable, IppsVQCodeBookState_32f** ppCodeBooks, int step, int height))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQCodeBookFree_32f
//
//  Purpose:
//    Closes the IppsVQCodeBookState_32f structure created by the function
//    ippsVQCodeBookInitAlloc.
//
//  Parameters:
//    pCodeBook             Pointer to specified IppsVQCodeBookState_32f
//                          structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pCodeBook pointer is
//                          NULL.
*/
IPPAPI(IppStatus, ippsVQCodeBookFree_32f, (IppsVQCodeBookState_32f* pCodeBook))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQCodeBookInit_32f
//
//  Purpose:
//    Initializes the codebook structure.
//
//  Parameters:
//    pInputTable           Pointer to the codebook table of the size step *
//                          height containing height quantization vectors of
//                          the length step.
//    ppCodeBook            Pointer to pointer to the codebook structure to
//                          be created.
//    step                  Step to the next line in the table InputTable,
//                          quantization vector length.
//    height                Table height, number of quantization vectors.
//    pMemSpec              Pointer to the area for the codebook structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pInputTable, ppCodeBook
//                          or pMemSpec pointer is NULL.
//    ippStsSizeErr         Indicates an error when the step or height is
//                          less than or equal to 0.
*/
IPPAPI(IppStatus, ippsVQCodeBookInit_32f, (const Ipp32f* pInputTable, IppsVQCodeBookState_32f** ppCodeBook , int step, int height, Ipp8u* pMemSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQPreliminarySelect_32f
//
//  Purpose:
//    Selects candidates for the nearest code vector of codebooks.
//
//  Parameters:
//    pSrc                  Source vector to be quantized.
//    pWeights              Pointer to the vector of weights.
//    nDiv                  Number of fragmentations of the src and weights
//                          vectors.
//    pLengths              Pointer to an array of lengths of fragmentations.
//    pIndx                 Pointer to the output vector of indexes of the
//                          nCand minimum candidates.
//    pSign                 Pointer to the output vector of signs of nCand
//                          minimum candidates: - The value of 1 indicates
//                          that the minimal distortion appears when the
//                          norm is negative; - The value of 0 indicates
//                          that the minimal distortion appears when the
//                          norm is positive.
//    nCand                 Number of output candidates.
//    pPolbits              Pointer to the polbits flag vector.
//    pCodeBook             Pointer to the specified IppsVQCodeBookState_32f
//                          structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pCodeBook or pSrc
//                          pointer is NULL.
*/
IPPAPI(IppStatus, ippsVQPreliminarySelect_32f, (const Ipp32f* pSrc, const Ipp32f* pWeights, int nDiv, const Ipp32s* pLengths, Ipp32s* pIndx, Ipp32s* pSign, int nCand, int* polbits, IppsVQCodeBookState_32f* pCodeBook))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQMainSelect_32f
//
//  Purpose:
//    Finds optimal indexes with minimal distortion.
//
//  Parameters:
//    pSrc                  Source vector to be quantized.
//    pWeights              Pointer to the vector of weights.
//    nDiv                  Number of fragmentations of the src and weights
//                          vectors.
//    pLengths              Pointer to an array of lengths of fragmentations.
//    nCand                 Number of input candidates.
//    ppIndexCand           Pointer to pointer to the input vectors of
//                          indexes of nCand minimum candidates.
//    ppSignCand            Pointer to pointer to the input vectors of signs
//                          of nCand minimum candidates.
//    ppIndx                Pointer to pointer to the output vectors of
//                          indexes.
//    ppSign                Pointer to pointer to the output vectors of signs.
//    ppCodeBooks           Pointer to pointer to the specified
//                          IppsVQCodeBookState_32f structures.
//    nCodeBooks            Number of codebooks.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
*/
IPPAPI(IppStatus, ippsVQMainSelect_32f, (const Ipp32f* pSrc, const Ipp32f* pWeights, const Ipp32s* pLengths, int nDiv, int nCand, Ipp32s** ppIndexCand, Ipp32s** ppSignCand, Ipp32s** ppIndx, Ipp32s** ppSign, IppsVQCodeBookState_32f** ppCodeBooks, int nCodeBooks))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQIndexSelect_32f
//
//  Purpose:
//    Finds optimal vector set for specified number of codebooks.
//
//  Parameters:
//    pSrc                  Source vector to be quantized.
//    pWeights              Pointer to the vector of weights.
//    nDiv                  Number of fragmentations of the src and weights
//                          vectors.
//    pLengths              Pointer to an array of lengths of fragmentations.
//    nCand                 Number of input candidates.
//    ppPolbits             Indicates whether one or two norms should be
//                          used to compute the optimal vector set for the
//                          specified number of codebooks.
//    ppIndx                Pointer to pointer to the output vectors of
//                          indexes.
//    ppSign                Pointer to pointer to the output vectors of signs.
//                          - The value of 1 indicates that the minimal
//                          distortion appears when the norm is negative.
//                          - The value of 0 indicates that the minimal
//                          distortion appears when the norm is positive.
//    ppCodeBooks           Pointer to pointer to the specified
//                          IppsVQCodeBookState_32f structures.
//    nCodeBooks            Number of codebooks.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
*/
IPPAPI(IppStatus, ippsVQIndexSelect_32f, (const Ipp32f* pSrc, const Ipp32f* pWeights, int nDiv, const Ipp32s* pLengths,  int nCand, int** ppPolbits, Ipp32s** ppIndx, Ipp32s** ppSign, IppsVQCodeBookState_32f** ppCodeBooks, int nCodeBooks))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQReconstruction_32f
//
//  Purpose:
//    Reconstructs vectors from indexes.
//
//  Parameters:
//    ppIndx                Pointer to pointer to an array of input vectors
//                          of indexes for each codebook.
//    ppSign                Pointer to pointer to an array of input vectors
//                          of signs for each codebook containing either 1
//                          or -1.
//    pLengths              Pointer to an array of lengths of partitions of
//                          output vector.
//    pDst                  Pointer to the reconstructed vector of spectrum
//                          values.
//    nDiv                  Number of partitions of output vector.
//    ppCodeBooks           Pointer to pointer to an array of pointers to
//                          specified IppsVQCodeBookState_32f structures.
//    nCodeBooks            Number of codebooks.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
*/
IPPAPI(IppStatus, ippsVQReconstruction_32f, (const Ipp32s** ppIndx, const Ipp32s** ppSign, const Ipp32s* pLength, int nDiv, int nStream, Ipp32f* pDst, IppsVQCodeBookState_32f** ppCodeBooks))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVQCodeBookGetSize_32f
//
//  Purpose:
//    Gets the size of the codebook structure.
//
//  Parameters:
//    step                  Step to the next line in the codebook table,
//                          quantization vector length.
//    height                Table height, number of quantization vectors.
//    pSizeState            Address of the codebook structure size value in
//                          bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSizeState pointer is
//                          NULL.
//    ippStsSizeErr         Indicates an error when the step or height is
//                          less than or equal to 0.
*/
IPPAPI(IppStatus, ippsVQCodeBookGetSize_32f, (int step, int height, int *pSizeState))

/****************************************************************************
 *                   MPEG4-SBR AUDIO
 ****************************************************************************/

 /*
 // DECODER PART
 */
/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterGetSize_SBR_RToC_32f,
//    ippsAnalysisFilterGetSize_SBR_RToC_32f32fc,
//    ippsAnalysisFilterGetSize_SBR_RToR_32f,
//    ippsSynthesisFilterGetSize_SBR_CToR_32f,
//    ippsSynthesisFilterGetSize_SBR_CToR_32fc32f,
//    ippsSynthesisFilterGetSize_SBR_RToR_32f
//    ippsSynthesisDownFilterGetSize_SBR_CToR_32f,
//    ippsSynthesisDownFilterGetSize_SBR_CToR_32fc32f,
//    ippsSynthesisDownFilterGetSize_SBR_RToR_32f
//
//  Purpose:
//    Returns size of QMF specification structures, init and work buffers.
//
//  Parameters:
//    pSizeSpec             Address of the FilterSpec_SBR specification
//                          structure size value in bytes.
//    pSizeInitBuf          Address size of the buffer for initialization
//                          functions in bytes.
//    pSizeWorkBuf          Address of the work buffer size value in bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
*/
IPPAPI( IppStatus, ippsAnalysisFilterGetSize_SBR_RToC_32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI( IppStatus, ippsAnalysisFilterGetSize_SBR_RToC_32f32fc, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI( IppStatus, ippsAnalysisFilterGetSize_SBR_RToR_32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisFilterGetSize_SBR_CToR_32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI(IppStatus, ippsSynthesisFilterGetSize_SBR_CToR_32fc32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisFilterGetSize_SBR_RToR_32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisDownFilterGetSize_SBR_CToR_32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisDownFilterGetSize_SBR_CToR_32fc32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisDownFilterGetSize_SBR_RToR_32f, ( int* pSizeSpec, int* pSizeInitBuf, int* pSizeWorkBuf ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterInit_SBR_RToC_32f
//
//  Purpose:
//    Initializes analysis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsAnalysisFilterInit_SBR_RToC_32f,
       ( IppsFilterSpec_SBR_C_32f** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterInit_SBR_CToR_32fc32f
//
//  Purpose:
//    Initializes analysis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsSynthesisFilterInit_SBR_CToR_32fc32f,
       ( IppsFilterSpec_SBR_C_32fc** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterInit_SBR_RToC_32f32fc
//
//  Purpose:
//    Initializes analysis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsAnalysisFilterInit_SBR_RToC_32f32fc,
       ( IppsFilterSpec_SBR_C_32fc** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterInit_SBR_RToR_32f
//
//  Purpose:
//    Initializes analysis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsAnalysisFilterInit_SBR_RToR_32f,
       ( IppsFilterSpec_SBR_R_32f** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterInit_SBR_CToR_32fc32f
//
//  Purpose:
//    Initializes synthesis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsSynthesisFilterInit_SBR_CToR_32f,
       ( IppsFilterSpec_SBR_C_32f** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterInit_SBR_RToR_32f
//
//  Purpose:
//    Initializes synthesis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsSynthesisFilterInit_SBR_RToR_32f,
       ( IppsFilterSpec_SBR_R_32f** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisDownFilterInit_SBR_CToR_32f
//
//  Purpose:
//    Initializes synthesis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsSynthesisDownFilterInit_SBR_CToR_32f,
       ( IppsFilterSpec_SBR_C_32f** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisDownFilterInit_SBR_CToR_32fc32f
//
//  Purpose:
//    Initializes down sample synthesis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsSynthesisDownFilterInit_SBR_CToR_32fc32f,
       ( IppsFilterSpec_SBR_C_32fc** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisDownFilterInit_SBR_RToR_32f
//
//  Purpose:
//    Initializes down sample synthesis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the FilterSpec_SBR
//                          specification structure is written. Onlt the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the FilterSpec_SBR
//                          specification structure.
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsSynthesisDownFilterInit_SBR_RToR_32f,
       ( IppsFilterSpec_SBR_R_32f** ppFilterSpec, Ipp8u* pMemSpec, Ipp8u* pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilter_SBR_RToC_32f_D2L
//    ippsAnalysisFilter_SBR_RToC_32f32fc_D2L
//    ippsAnalysisFilter_SBR_RToR_32f_D2L
//
//  Purpose:
//    Splits time domain signal output from the core decoder into 32
//    subband signals.
//
//  Parameters:
//    pSrc                  Pointer to the input audio signal.
//    pDst                  array of pointers, holds subband samples.
//    pDstRe                array of pointers  that contains real parts of subband samples.
//    pDstIm                array of pointers that contains imaginary parts of subband
//                          samples.
//    pSbrTableWindowDown   Pointer to the window table that is used by decoder SBR Analysis Filter.
//    offset                Desired displacement in number of rows when the matrix pDst is calculated. offset >=0
//    NumLoop               Parameter equal to 32 if frame size of the core decoded signal is 1024
//                          30 if frame size of the core decoded signal is 960.
//    kx                    first SBR subband in the SBR range.
//    pFilterSpec           Pointer to the FilterSpec_SBR specification structure.
//    pWorkBuf              Pointer to the work buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsAnalysisFilter_SBR_RToC_32f_D2L,
       (const Ipp32f* pSrc, Ipp32f* pDstRe[], Ipp32f* pDstIm[], const Ipp32f* pSbrTableWinDown,
       int NumLoop, int offset, int kx,
       const IppsFilterSpec_SBR_C_32f* pFilterSpec, Ipp8u* pWorkBuf))
IPPAPI( IppStatus, ippsAnalysisFilter_SBR_RToC_32f32fc_D2L,
       (const Ipp32f* pSrc, Ipp32fc* pDst[], const Ipp32f* pSbrTableWinDown,
       int NumLoop, int offset, int kx,
       const IppsFilterSpec_SBR_C_32fc* pFilterSpec, Ipp8u* pWorkBuf))
IPPAPI( IppStatus, ippsAnalysisFilter_SBR_RToR_32f_D2L,
       (const Ipp32f* pSrc, Ipp32f* pDst[], const Ipp32f* pSbrTableWinDown,
       int NumLoop, int offset, int kx,
       const IppsFilterSpec_SBR_R_32f* pFilterSpec, Ipp8u* pWorkBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilter_SBR_CToR_32f_D2L
//    ippsSynthesisFilter_SBR_CToR_32fc32f_D2L
//    ippsSynthesisFilter_SBR_RToR_32f_D2L
//
//  Purpose:
//    Transforms SBR-processed subband signals into time domain samples.
//
//  Parameters:
//      pSrc       - array of pointers, holds SBR-processed subband signals.
//      pSrcRe     - array of pointers that contains real parts of SBR-processed subband signals.
//      pSrcIm     - array of pointers that contains imaginary parts of SBR-processed subband signals.
//      pDst       - Pointer to the output vector, holds time domain output samples.
//      pSbrTableWindow - Pointer to the window table that is used by SBR Analysis Filter.
//      NumLoop    - Parameter equal to 32 if frame size of the core decoded signal is 1024
//      30 if frame size of the core decoded signal is 960.
//      pFilterSpec- Pointer to the FilterSpec_SBR specification structure.
//      pWorkBuf   - Pointer to the work buffer used by the filter.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI( IppStatus, ippsSynthesisFilter_SBR_CToR_32f_D2L,
       (const Ipp32f* pSrcRe[], const Ipp32f* pSrcIm[], Ipp32f* pDst, const Ipp32f* pSbrTableWindow,
       int NumLoop, const IppsFilterSpec_SBR_C_32f* pFilterSpec, Ipp8u* pWorkBuf))
IPPAPI( IppStatus, ippsSynthesisFilter_SBR_CToR_32fc32f_D2L,
       (const Ipp32fc* pSrc[], Ipp32f* pDst, const Ipp32f* pSbrTableWindow, int NumLoop,
       const IppsFilterSpec_SBR_C_32fc* pFilterSpec, Ipp8u* pWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisFilter_SBR_RToR_32f_D2L,
       (const Ipp32f* pSrc[], Ipp32f* pDst, const Ipp32f* pSbrTableWindow, int NumLoop,
       const IppsFilterSpec_SBR_R_32f* pFilterSpec, Ipp8u* pWorkBuf ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:       ippsSynthesisDownFilter_SBR_CToR_32f_D2L, ippsSynthesisDownFilter_SBR_CToR_32fc32f_D2L, ippsSynthesisDownFilter_SBR_RToR_32f_D2L
//  Purpose:    Transforms SBR-processed subband signals into time domain samples and
//              performs downsampling at the same time.
//
//  Parameters:
//      pSrc   - array of pointers, holds SBR-processed subband signals.
//      pSrcRe - array of pointers that contains real parts of SBR-processed subband signals.
//      pSrcIm - array of pointers that contains imaginary parts of SBR-processed subband signals.
//      pDst   - Pointer to the output vector, holds time domain output samples.
//      pSbrTableWindowDown  - Pointer to the window table that is used by SBR Analysis Filter.
//      NumLoop- Parameter equal to 32 if frame size of the core decoded signal is 1024
//      30 if frame size of the core decoded signal is 960.
//      pFilterSpec  - Pointer to the FilterSpec_SBR specification structure.
//      pWorkBuf     - Pointer to the work buffer used by the filter.
//
//  Return Values:     status
*/
IPPAPI( IppStatus, ippsSynthesisDownFilter_SBR_CToR_32f_D2L,
       (const Ipp32f* pSrcRe[],const Ipp32f* pSrcIm[], Ipp32f* pDst,
       const Ipp32f* pSbrTableWindowDown, int NumLoop,
       const IppsFilterSpec_SBR_C_32f* pFilterSpec, Ipp8u* pWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisDownFilter_SBR_CToR_32fc32f_D2L,
       (const Ipp32fc* pSrc[], Ipp32f* pDst, const Ipp32f* pSbrTableWindowDown, int NumLoop,
       const IppsFilterSpec_SBR_C_32fc* pFilterSpec, Ipp8u* pWorkBuf ))
IPPAPI( IppStatus, ippsSynthesisDownFilter_SBR_RToR_32f_D2L,
       (const Ipp32f* pSrc[], Ipp32f* pDst, const Ipp32f* pSbrTableWindowDown, int NumLoop,
       const IppsFilterSpec_SBR_R_32f* pFilterSpec, Ipp8u* pWorkBuf ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:       ippsPredictCoef_SBR_R_32f_D2L, ippsPredictCoef_SBR_C_32fc_D2L, ippsPredictCoef_SBR_C_32f_D2L
//  Purpose:    Obtains prediction filter coefficients using covariance method.
//
//  Parameters:
//      pSrc    - array of pointers holds input real or complex matrix ([40][32]),
//                holds Low Frequency QMF-processed subband signals.
//      pSrcRe  - array of pointers ([40][32]) that contains real
//                parts of Low Frequency SBR-processed subband signals.
//      pSrcIm  - array of pointers ([40][32]) that contains
//                imaginary parts of Low Frequency SBR-processed subband signals.
//      k0      - First QMF subband in the f_master table.
//      len     - Size autocorrelation.
//      pAlpha0, pAlpha1     - Pointers to the  arrays that contain complex
//                             or real Prediction filter coefficients used by High Frequency filter.
//      pAlpha0Re, pAlpha1Re - Pointers to the  arrays that contain real parts of the
//                             corresponding complex filter coefficients.
//      pAlpha0Im, pAlpha1Im - Pointers to the arrays that contain imaginary parts of the
//                             corresponding complex filter coefficients.
//
//  Return Values:     status
*/
IPPAPI( IppStatus, ippsPredictCoef_SBR_R_32f_D2L,
       (const Ipp32f* pSrc[], Ipp32f* pAlpha0, Ipp32f* pAlpha1, int k0, int len))
IPPAPI( IppStatus, ippsPredictCoef_SBR_C_32fc_D2L,
       (const Ipp32fc* pSrc[], Ipp32fc* pAlpha0, Ipp32fc* pAlpha1, int k0, int len))
IPPAPI( IppStatus, ippsPredictCoef_SBR_C_32f_D2L,
                                            (const Ipp32f* pSrcRe[], const Ipp32f* pSrcIm[],
                                            Ipp32f* pAlpha0Re, Ipp32f* pAlpha0Im,
                                            Ipp32f* pAlpha1Re, Ipp32f* pAlpha1Im,
                                            int k0, int len))

IPPAPI( IppStatus, ippsPredictOneCoef_SBRHQ_32sc_D2L,
       (const Ipp32sc* pSrc[], Ipp32sc* pAlpha0, Ipp32sc* pAlpha1, int k, int lenCorr))

IPPAPI( IppStatus, ippsPredictOneCoef_SBRLP_32s_D2L,
       (const Ipp32s* pSrc[], Ipp32s* pAlpha0, Ipp32s* pAlpha1,
        Ipp32s* pRefCoef, int k, int lenCorr, int flag))

/****************************************************************************
 * FIXED-POINT VERSION
 *
 *
 ****************************************************************************/

 /* <-------------------- HQ MODE --------------------------> */

  /* GET SIZE */
  IPPAPI( IppStatus, ippsAnalysisFilterGetSize_SBRHQ_32s32sc, ( int* pSizeSpec ))

  IPPAPI( IppStatus, ippsSynthesisFilterGetSize_SBRHQ_32sc32s, ( int* pSizeSpec ))

  IPPAPI( IppStatus, ippsSynthesisDownFilterGetSize_SBRHQ_32sc32s, ( int* pSizeSpec))

  /* INIT */
  IPPAPI( IppStatus, ippsAnalysisFilterInit_SBRHQ_32s32sc,
       ( IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilterInit_SBRHQ_32sc32s,
       ( IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisDownFilterInit_SBRHQ_32sc32s,
       ( IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  /* INITALLOC */
  IPPAPI( IppStatus, ippsAnalysisFilterInitAlloc_SBRHQ_32s32sc,
       ( IppsFilterSpec_SBR_C_32sc** ppFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilterInitAlloc_SBRHQ_32sc32s,
       ( IppsFilterSpec_SBR_C_32sc** ppFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisDownFilterInitAlloc_SBRHQ_32sc32s,
       ( IppsFilterSpec_SBR_C_32sc** ppFilterSpec))

  /* FREE */
  IPPAPI( IppStatus, ippsAnalysisFilterFree_SBRHQ_32s32sc,
       ( IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilterFree_SBRHQ_32sc32s,
       ( IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisDownFilterFree_SBRHQ_32sc32s,
       ( IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  /* MAIN */
  IPPAPI( IppStatus, ippsAnalysisFilter_SBRHQ_32s32sc,
       (const Ipp32s* pSrc, Ipp32sc* pDst,int kx,
        const IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilter_SBRHQ_32sc32s,
       (const Ipp32sc* pSrc, Ipp32s* pDst,
        const IppsFilterSpec_SBR_C_32sc* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisDownFilter_SBRHQ_32sc32s,
       (const Ipp32sc* pSrc, Ipp32s* pDst,
        const IppsFilterSpec_SBR_C_32sc* pFilterSpec ))

/* <-----------------------LP MODE -----------------------> */

  /* GET SIZE */
  IPPAPI( IppStatus, ippsAnalysisFilterGetSize_SBRLP_32s, ( int* pSizeSpec ))

  IPPAPI( IppStatus, ippsSynthesisFilterGetSize_SBRLP_32s, ( int* pSizeSpec ))

  IPPAPI( IppStatus, ippsSynthesisDownFilterGetSize_SBRLP_32s, ( int* pSizeSpec ))

  /* INIT */
  IPPAPI( IppStatus, ippsAnalysisFilterInit_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilterInit_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisDownFilterInit_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s* pFilterSpec))

  /* INITALLOC */
  IPPAPI( IppStatus, ippsAnalysisFilterInitAlloc_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s** ppFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilterInitAlloc_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s** ppFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisDownFilterInitAlloc_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s** ppFilterSpec))

  /* FREE */
  IPPAPI( IppStatus, ippsAnalysisFilterFree_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilterFree_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisDownFilterFree_SBRLP_32s,
       ( IppsFilterSpec_SBR_R_32s* pFilterSpec))

  /* MAIN */
  IPPAPI( IppStatus, ippsAnalysisFilter_SBRLP_32s,
       (const Ipp32s* pSrc, Ipp32s* pDst,int kx,
        const IppsFilterSpec_SBR_R_32s* pFilterSpec))

  IPPAPI( IppStatus, ippsSynthesisFilter_SBRLP_32s,
       (const Ipp32s* pSrc, Ipp32s* pDst,
        const IppsFilterSpec_SBR_R_32s* pFilterSpec ))

  IPPAPI( IppStatus, ippsSynthesisDownFilter_SBRLP_32s,
       (const Ipp32s* pSrc, Ipp32s* pDst,
        const IppsFilterSpec_SBR_R_32s* pFilterSpec ))

/*
// ENCODER PART
*/

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterEncGetSize_SBR_32f
//
//  Purpose:
//    Returns size of FilterSpec_SBR specification structures & init buffer.
//
//  Parameters:
//    pSizeSpec             Address of the FilterSpec_SBR specification
//                          structure size value in bytes.
//    pSizeInitBuf          Address size of the buffer for initialization
//                          functions in bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
*/
IPPAPI(IppStatus, ippsAnalysisFilterEncGetSize_SBR_32f,
       (int *pSizeSpec,
       int *pSizeInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterInitEnc_SBR_32f
//
//  Purpose:
//    Initializes analysis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to FilterSpec_SBR specification structure
//
//    pInitBuf              Pointer to the Init buffer.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier pFilterSpec is
//                          incorrect.
*/

IPPAPI(IppStatus, ippsAnalysisFilterEncInit_SBR_32f,
       (IppsFilterSpec_SBR_C_32fc  *ppFilterSpec,
       Ipp8u                      *pInitBuf))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterEncInitAlloc_SBR_32f
//
//  Purpose:
//    Allocate memory for analysis specification structure and initializes it.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the IppsFilterSpec_SBR
//                          specification structure is written.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppFilterSpec is NULL.
*/

IPPAPI(IppStatus, ippsAnalysisFilterEncInitAlloc_SBR_32f, (IppsFilterSpec_SBR_C_32f **ppFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterEncFree_SBR_32f
//
//  Purpose:
//    Frees memory allocated for internal IppsFilterSpec_SBR structure.
//
//  Parameters:
//    pFilterSpec           Pointer to the IppsFilterSpec_SBR specification
//                          structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pFilterSpec is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/

IPPAPI(IppStatus, ippsAnalysisFilterEncFree_SBR_32f, (IppsFilterSpec_SBR_C_32f *pFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterEnc_SBR_32f32fc
//
//  Purpose:
//    Splits time domain signal output from the core decoder into 32 subband
//    signals.
//
//  Parameters:
//    pSrc                  Pointer to the input audio signal.
//
//    pDst                  Pointer to the output signal
//
//    pFilterSpec           Pointer to the FilterSpec_SBR specification
//                          structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
//
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/

IPPAPI(IppStatus, ippsAnalysisFilterEnc_SBR_32f32fc,
       (const Ipp32f   *pSrc,
       Ipp32fc        *pDst,
       const IppsFilterSpec_SBR_C_32f  *pFilterSpec))


/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDetectTransient_SBR_32f
//
//  Purpose:
//    Transient detection is done by function.
//
//  Parameters:
//    pSrc                  pointer to the vector which stores the spectrum component of audio signal.
//
//    pInOutThr            Pointer to the threshold of deviation.
//
//    pDst                 pointer to the transient threshold
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
*/

IPPAPI( IppStatus, ippsDetectTransient_SBR_32f, (const Ipp32f* pSrc, Ipp32f* pInOutThr, Ipp32f* pDst))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsEstimateTNR_SBR_32f
//
//  Purpose:
//    Function estimates Tonality-To-Noise Ratio of audio signal.
//
//  Parameters:
//    pSrc                 pointer to the vector which stores the spectrum component of audio signal
//
//    pTNR0                Pointer to first estimation of TNR.
//
//    pTNR1                Pointer to second estimation of TNR
//
//    pMeanNrg             pointer
//
//  Returns:
//    ippStsNoErr          Indicates no error.
//    ippStsNullPtrErr     Indicates an error when any of the specified
//                         pointers is NULL.
*/

IPPAPI( IppStatus, ippsEstimateTNR_SBR_32f, (const Ipp32fc* pSrc, Ipp32f* pTNR0, Ipp32f* pTNR1, Ipp32f* pMeanNrg))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsUnpackFrameHeader_MP3
//
//  Purpose:
//    Unpacks audio frame header.
//
//  Parameters:
//    ppBitStream           Pointer to the pointer to the first byte of the
//                          MP3 frame header (*ppBitstream will be updated
//                          in the function).
//    pFrameHeader          Pointer to the MP3 frame header structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppBitStreamp or
//                          FrameHeader is NULL.
*/

IPPAPI( IppStatus, ippsAnalysisFilter_PS_32fc_D2, (const Ipp32fc* pSrc, Ipp32fc ppDst[32][12],
                                                   IppAC_PS_DEC_ANALYSIS config))
/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilter_PS_32fc_D2
//
//  Purpose:
//    Increases frequency resolution of the first few lower subbands by hybrid filtering
//
//  Parameters:
//    pSrc                  Pointer to the lower QMF subband
//    ppDst                 Output matrix, contains hybrid subband samples
//    config                flag describing configuration of hybrid filtering
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the specified pointers is NULL.
//    ippStsBadArgErr       Indicates an error when config isn't correct
*/

IPPAPI(IppStatus, ippsUnpackFrameHeader_MP3, (
  Ipp8u**            ppBitStream,
  IppMP3FrameHeader* pFrameHeader))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsUnpackSideInfo_MP3
//
//  Purpose:
//    Unpacks side information from input bitstream for use during decoding
//    of associated frame.
//
//  Parameters:
//    ppBitStream           Pointer to the pointer to the first byte of the
//                          side information associated with the current
//                          frame in the bit stream buffer. The function
//                          updates this parameter.
//    pFrameHeader          Pointer to the structure that contains the
//                          unpacked MP3 frame header. The header structure
//                          provides format information about the input
//                          bitstream. Both single- and dual-channel MPEG-1
//                          and MPEG-2 modes are supported.
//    pDstSideInfo          Pointer to the MP3 side information structure.
//                          The structure contains side information that
//                          applies to all granules and all channels for the
//                          current frame. One or more of the structures are
//                          placed contiguously in the buffer pointed to by
//                          pDstSideInfo in the following order:
//                          {granule 0 (channel 0, channel 1), granule 1 (channel
//                          channel 1)}.
//    pDstMainDataBegin     Pointer to the main_data_begin field.
//    pDstPrivateBits       Pointer to the private bits field.
//    pDstScfsi             Pointer to the scale factor selection
//                          information associated with the current frame.
//                          The data is organized contiguously in the buffer
//                          pointed to by pDstScfsi in the following order:
//                          {channel 0 (scfsi_band 0, scfsi_band 1, ...,
//                          scfsi_band 3), channel 1 (scfsi_band 0,
//                          scfsi_band 1, ..., [, fsi_band 3)}.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pDstSideInfo,
//                          pDstMainDataBegin, pDstPrivateBits, pDstScfsi,
//                          pFrameHeader, or ppBitStream is NULL.
//    ippStsMP3FrameHeaderErr Indicates an error when some elements in the
//                          MP3 frame header structure are invalid:
//                          pFrameHeader->id != IPP_MP3_ID_MPEG1
//                          pFrameHeader->id != IPP_MP3_ID_MPEG2
//                          pFrameHeader->layer != 1 pFrameHeader->mode < 0
//                          pFrameHeader->mode > 3.
//    ippStsMP3SideInfoErr  Indicates an error when the value of block_type
//                          is zero when window_switching_flag is set.
*/
IPPAPI(IppStatus, ippsUnpackSideInfo_MP3, (
  Ipp8u**            ppBitStream,
  IppMP3SideInfo*    pDstSideInfo,
  int*               pDstMainDataBegin,
  int*               pDstPrivateBits,
  int*               pDstScfsi,
  IppMP3FrameHeader* pFrameHeader))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsUnpackScaleFactors_MP3_1u8s
//
//  Purpose:
//    Unpacks scalefactors.
//
//  Parameters:
//    ppBitStream           Pointer to the pointer to the first bitstream
//                          buffer byte associated with the scale factors
//                          for the current frame, granule, and channel. The
//                          function updates this parameter.
//    pOffSet               Pointer to the next bit in the byte referenced by *
//                          ppBitStream. Valid within the range of 0 to 7,
//                          where 0 corresponds to the most significant bit
//                          and 7 corresponds to the least significant bit.
//                          The function updates this parameter.
//    pDstScaleFactor       Pointer to the scalefactor vector for long and/
//                          or short blocks.
//    pSideInfo             Pointer to the MP3 side information structure
//                          associated with the current granule and channel.
//    pScfsi                Pointer to scale factor selection information
//                          for the current channel.
//    pFrameHeader          Pointer to MP3 frame header structure for the
//                          current frame.
//    granule               Granule index. Can take the values
//                          of either 0 or 1.
//    channel               Channel index. Can take the values of either 0
//                          or 1.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppBitStream, pOffset,
//                          pDstScaleFactor, pSideInfo, pScfsi, ppBitStream,
//                          or pFrameHeader is NULL.
*/
IPPAPI(IppStatus, ippsUnpackScaleFactors_MP3_1u8s, (
  Ipp8u**            ppBitStream,
  int*               pOffset,
  Ipp8s*             pDstScaleFactor,
  IppMP3SideInfo*    pSideInfo,
  int*               pScfsi,
  IppMP3FrameHeader* pFrameHeader,
  int                granule,
  int                channel))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsHuffmanDecode_MP3_1u32s
//
//  Purpose:
//    Decodes Huffman data.
//
//  Parameters:
//    ppBitStream           Pointer to the pointer to the first bit stream
//                          byte that contains the Huffman code words
//                          associated with the current granule and channel.
//                          The function updates this parameter.
//    pOffset               Pointer to the starting bit position in the bit
//                          stream byte pointed to by *ppBitStream.
//                          The parameter is valid within the
//                          range of 0 to 7, where 0 corresponds to the most
//                          significant bit, and 7 corresponds to the least
//                          significant bit. The function updates this
//                          parameter.
//    pDstIs                Pointer to the vector of decoded Huffman symbols
//                          used to compute the quantized values of the 576
//                          spectral coefficients associated with the
//                          current granule and channel.
//    pDstNonZeroBound      Pointer to the spectral region above which all
//                          coefficients are set to zero.
//    pSideInfo             Pointer to MP3 structure containing side
//                          information associated with the current granule
//                          and channel.
//    pFrameHeader          Pointer to MP3 structure containing the header
//                          associated with the current frame.
//    hufSize               The number of Huffman code bits associated with
//                          the current granule and channel.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, pDstIs,
//                          pDstNonZeroBound, pSideInfo, pFrameHeader, or
//                          ppBitStream is NULL or when pOffset < 0 or
//                          pOffset > 7.
//    ippStsMP3FrameHeaderErr Indicates an error when some elements in the
//                          MP3 frame header structure are invalid.
//    ippStsMP3SideInfoErr  Indicates an error when some elements in the MP3
//                          side information structure are invalid or when
//                          hufSize < 0 or hufSize > pSideInfo->part23Len.
//    ippStsErr             Indicates unknown error.
*/
IPPAPI(IppStatus, ippsHuffmanDecode_MP3_1u32s, (
  Ipp8u**            ppBitStream,
  int*               pOffset,
  Ipp32s*            pDstIs,
  int*               pDstNonZeroBound,
  IppMP3SideInfo*    pSideInfo,
  IppMP3FrameHeader* pFrameHeader,
  int                hufSize))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsHuffmanDecodeSfb_MP3_1u32s
//
//  Purpose:
//    Decodes Huffman data.
//
//  Parameters:
//    ppBitStream           Pointer to the pointer to the first bit stream
//                          byte that contains the Huffman code words
//                          associated with the current granule and channel.
//                          The function updates this parameter.
//    pOffset               Pointer to the starting bit position in the bit
//                          stream byte pointed to by *ppBitStream.
//                          The parameter is valid within the
//                          range of 0 to 7, where 0 corresponds to the most
//                          significant bit, and 7 corresponds to the least
//                          significant bit. The function updates this
//                          parameter.
//    pDstIs                Pointer to the vector of decoded Huffman symbols
//                          used to compute the quantized values of the 576
//                          spectral coefficients associated with the
//                          current granule and channel.
//    pDstNonZeroBound      Pointer to the spectral region above which all
//                          coefficients are set to zero.
//    pSideInfo             Pointer to MP3 structure containing side
//                          information associated with the current granule
//                          and channel.
//    pFrameHeader          Pointer to MP3 structure containing the header
//                          associated with the current frame.
//    hufSize               The number of Huffman code bits associated with
//                          the current granule and channel.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, pDstIs,
//                          pDstNonZeroBound, pSideInfo, pFrameHeader, or
//                          ppBitStream is NULL or when pOffset < 0 or
//                          pOffset > 7.
//    ippStsMP3FrameHeaderErr Indicates an error when some elements in the
//                          MP3 frame header structure are invalid.
//    ippStsMP3SideInfoErr  Indicates an error when some elements in the MP3
//                          side information structure are invalid or when
//                          hufSize < 0 or hufSize > pSideInfo->part23Len.
//    ippStsErr             Indicates unknown error.
*/
IPPAPI(IppStatus, ippsHuffmanDecodeSfb_MP3_1u32s, (
  Ipp8u**            ppBitStream,
  int*               pOffset,
  Ipp32s*            pDstIs,
  int*               pDstNonZeroBound,
  IppMP3SideInfo*    pSideInfo,
  IppMP3FrameHeader* pFrameHeader,
  int                hufSize,
  IppMP3ScaleFactorBandTableLong pSfbTableLong))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsHuffmanDecodeSfbMbp_MP3_1u32s
//
//  Purpose:
//    Decodes Huffman data.
//
//  Parameters:
//    ppBitStream           Pointer to the pointer to the first bit stream
//                          byte that contains the Huffman code words
//                          associated with the current granule and channel.
//                          The function updates this parameter.
//    pOffset               Pointer to the starting bit position in the bit
//                          stream byte pointed to by *ppBitStream.
//                          The parameter is valid within the
//                          range of 0 to 7, where 0 corresponds to the most
//                          significant bit, and 7 corresponds to the least
//                          significant bit. The function updates this
//                          parameter.
//    pDstIs                Pointer to the vector of decoded Huffman symbols
//                          used to compute the quantized values of the 576
//                          spectral coefficients associated with the
//                          current granule and channel.
//    pDstNonZeroBound      Pointer to the spectral region above which all
//                          coefficients are set to zero.
//    pSideInfo             Pointer to MP3 structure containing side
//                          information associated with the current granule
//                          and channel.
//    pFrameHeader          Pointer to MP3 structure containing the header
//                          associated with the current frame.
//    hufSize               The number of Huffman code bits associated with
//                          the current granule and channel.
//    pSfbTableLong         Pointer to the scale factor bands table for a
//                          long block.
//    pSfbTableShort        Pointer to scale factor band table for short
//                          block. You can use the default table from
//                          MPEG-1, MPEG-2 standards.
//    pMbpTable             Pointer to the mixed block partition table.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, pDstIs,
//                          pDstNonZeroBound, pSideInfo, pFrameHeader, or
//                          ppBitStream is NULL or when pOffset < 0 or
//                          pOffset > 7.
//    ippStsMP3FrameHeaderErr Indicates an error when some elements in the
//                          MP3 frame header structure are invalid.
//    ippStsMP3SideInfoErr  Indicates an error when some elements in the MP3
//                          side information structure are invalid or when
//                          hufSize < 0 or hufSize > pSideInfo->part23Len.
//    ippStsErr             Indicates unknown error.
*/
IPPAPI(IppStatus, ippsHuffmanDecodeSfbMbp_MP3_1u32s, (
  Ipp8u**            ppBitStream,
  int*               pOffset,
  Ipp32s*            pDstIs,
  int*               pDstNonZeroBound,
  IppMP3SideInfo*    pSideInfo,
  IppMP3FrameHeader* pFrameHeader,
  int                hufSize,
  IppMP3ScaleFactorBandTableLong    pSfbTableLong,
  IppMP3ScaleFactorBandTableShort   pSfbTableShort,
  IppMP3MixedBlockPartitionTable    pMbpTable))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsReQuantize_MP3_32s_I
//
//  Purpose:
//    Requantizes the decoded Huffman symbols.
//
//  Parameters:
//    pSrcDstIsXr           Pointer to the vector of the decoded Huffman
//                          symbols. For stereo and dual channel modes,
//                          right channel data begins at the address &(
//                          pSrcDstIsXr[576]). The function updates this
//                          vector.
//    pNonZeroBound         Pointer to the spectral bound above which all
//                          coefficients are set to zero. For stereo and
//                          dual channel modes, the left channel bound is
//    pNonZeroBound         [0], and the right channel bound is pNonZeroBound
//    [,\.
//    pScaleFactor          Pointer to the scalefactor buffer. For stereo
//                          and dual channel modes, the right channel
//                          scalefactors begin at & (pScaleFactor [
//                          IPP_MP3_SF_BUF_LEN]).
//    pSideInfo             Pointer to the side information for the current
//                          granule.
//    pFrameHeader          Pointer to the frame header for the current frame.
//    pBuffer               Pointer to the workspace buffer. The buffer
//                          length must be 576 samples.
//    pSfbTableLong         Pointer to the scale factor bands table for a
//                          long block.
//    pSfbTableShort        Pointer to the scale factor bands table for a
//                          short block.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSrcDstIsXr,
//                          pNonZeroBound, pScaleFactor, pSideInfo,
//                          pFrameHeader, or pBuffer is NULL.
//    ippStsBadArgErr       Indicates an error when pNonZeroBound exceeds [0
//                          , 576].
//    ippStsMP3FrameHeaderErr Indicates an error when
//                          pFrameHeader->id != IPP_MP3_ID_MPEG1
//                          pFrameHeader->id != IPP_MP3_ID_MPEG2
//                          pFrameHeader->samplingFreq exceeds [0, 2],
//                          pFrameHeader->mode exceeds [0, 3],
//                          pFrameHeader->modeExt exceeds [0, 3].
//    ippStsMP3SideInfoErr  Indicates an error when the bitstream is in the
//                          stereo mode, but the block type of left is
//                          different from that of right, pSideInfo[ch].
//                          blockType exceeds [0, 3], pSideInfo[ch].
//                          mixedBlock exceeds [0, 1], pSideInfo[ch].
//                          globGain exceeds [0, 255], pSideInfo[ch].sfScale
//                          exceeds [0, 1], pSideInfo[ch].preFlag exceeds [0
//                          , 1], pSideInfo[ch].pSubBlkGain[w] exceeds [0, 7
//                          ], where ch is within the range of 0 to 1, and w
//                          is within the range of 0 to 2.
//    ippStsErr             Indicates an unknown error.
*/
IPPAPI(IppStatus, ippsReQuantize_MP3_32s_I, (
  Ipp32s*            pSrcDstIsXr,
  int*               pNonZeroBound,
  Ipp8s*             pScaleFactor,
  IppMP3SideInfo*    pSideInfo,
  IppMP3FrameHeader* pFrameHeader,
  Ipp32s*            pBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsReQuantizeSfb_MP3_32s_I
//
//  Purpose:
//    Requantizes the decoded Huffman symbols.
//
//  Parameters:
//    pSrcDstIsXr           Pointer to the vector of the decoded Huffman
//                          symbols. For stereo and dual channel modes,
//                          right channel data begins at the address &(
//                          pSrcDstIsXr[576]). The function updates this
//                          vector.
//    pNonZeroBound         Pointer to the spectral bound above which all
//                          coefficients are set to zero. For stereo and
//                          dual channel modes, the left channel bound is
//                          pNonZeroBound[0], and the right channel bound
//                          is pNonZeroBound[1].
//    pScaleFactor          Pointer to the scalefactor buffer. For stereo
//                          and dual channel modes, the right channel
//                          scalefactors begin at & (pScaleFactor [
//                          IPP_MP3_SF_BUF_LEN]).
//    pSideInfo             Pointer to the side information for the current
//                          granule.
//    pFrameHeader          Pointer to the frame header for the current frame.
//    pBuffer               Pointer to the workspace buffer. The buffer
//                          length must be 576 samples.
//    pSfbTableLong         Pointer to the scale factor bands table for a
//                          long block.
//    pSfbTableShort        Pointer to the scale factor bands table for a
//                          short block.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSrcDstIsXr,
//                          pNonZeroBound, pScaleFactor, pSideInfo,
//                          pFrameHeader, or pBuffer is NULL.
//    ippStsBadArgErr       Indicates an error when pNonZeroBound exceeds
//                          [0, 576].
//    ippStsMP3FrameHeaderErr Indicates an error when
//                          pFrameHeader->id != IPP_MP3_ID_MPEG1
//                          pFrameHeader->id != IPP_MP3_ID_MPEG2
//                          pFrameHeader->samplingFreq exceeds [0, 2],
//                          pFrameHeader->mode exceeds [0, 3],
//                          pFrameHeader->modeExt exceeds [0, 3].
//    ippStsMP3SideInfoErr  Indicates an error when the bitstream is in the
//                          stereo mode, but the block type of left is
//                          different from that of right, pSideInfo[ch].
//                          blockType exceeds [0, 3], pSideInfo[ch].
//                          mixedBlock exceeds [0, 1], pSideInfo[ch].
//                          globGain exceeds [0, 255], pSideInfo[ch].sfScale
//                          exceeds [0, 1], pSideInfo[ch].preFlag exceeds [0
//                          , 1], pSideInfo[ch].pSubBlkGain[w] exceeds [0, 7
//                          ], where ch is within the range of 0 to 1, and w
//                          is within the range of 0 to 2.
//    ippStsErr             Indicates an unknown error.
*/
IPPAPI(IppStatus, ippsReQuantizeSfb_MP3_32s_I, (
  Ipp32s*            pSrcDstIsXr,
  int*               pNonZeroBound,
  Ipp8s*             pScaleFactor,
  IppMP3SideInfo*    pSideInfo,
  IppMP3FrameHeader* pFrameHeader,
  Ipp32s*            pBuffer,
  IppMP3ScaleFactorBandTableLong  pSfbTableLong,
  IppMP3ScaleFactorBandTableShort pSfbTableShort))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInv_MP3_32s
//
//  Purpose:
//    Performs the first stage of hybrid synthesis filter bank.
//
//  Parameters:
//    pSrcXr                Pointer to the vector of requantized spectral
//                          samples for the current channel and granule,
//                          represented in Q5.26 format.
//    pDstY                 Pointer to the vector of IMDCT outputs in Q7.24
//                          format for input to PQMF bank.
//    pSrcDstOverlapAdd     Pointer to the overlap-add buffer. Contains the
//                          overlapped portion of the previous granule IMDCT
//                          output in Q7.24 format. The function updates
//                          this buffer.
//    nonZeroBound          Limiting bound for spectral coefficients. All
//                          spectral coefficients exceeding this boundary
//                          become zero for the current granule and channel.
//    pPrevNumOfImdct       Pointer to the number of IMDCTs computed for the
//                          current channel of the previous granule. The
//                          function updates this parameter so that it
//                          references the number of IMDCTs for the current
//                          granule.
//    blockType             Block type indicator.
//    mixedBlock            Mixed block indicator.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsBadArgErr       Indicates an error condition if at least one of
//                          the specified pointers is NULL.
//    ippStsErr             Indicates an error when one or more of the
//                          following input data errors are detected: either
//                          blockType exceeds [0,3], or mixedBlock exceeds [0
//                          ,1], or nonZeroBound exceeds [0,576], or *
//                          pPrevNumOfImdct exceeds [0,32].
*/
IPPAPI(IppStatus, ippsMDCTInv_MP3_32s, (
  Ipp32s* pSrcXr,
  Ipp32s* pDstY,
  Ipp32s* pSrcDstOverlapAdd,
  int     nonZeroBound,
  int*    pPrevNumOfImdct,
  int     blockType,
  int     mixedBlock))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthPQMF_MP3_32s16s
//
//  Purpose:
//    Performs the second stage of hybrid synthesis filter bank.
//
//  Parameters:
//    pSrcY                 Pointer to the block of 32 IMDCT sub-band input
//                          samples in Q7.24 format.
//    pDstAudioOut          Pointer to the block of 32 reconstructed PCM
//                          output samples in 16-bit signed little-endian
//                          format. Left and right channels are interleaved
//                          according to the mode flag.
//    pVBuffer              Pointer to the input workspace buffer containing
//                          Q7.24 data. The function updates this parameter.
//                          NOTE. Note that the pointers pSrcXr and pDstY
//                          must reference different buffers. 10-104 10
//                          Intel Integrated Performance Primitives
//                          Reference Manual: Volume 1
//    pVPosition            Pointer to the internal workspace index. The
//                          function updates this parameter.
//    mode                  Flag that indicates whether or not PCM audio
//                          output channels should be interleaved. 1
//                          indicates not interleaved, 2 indicates
//                          interleaved.
//
//  Returns:
//    ippStsNoErr           Indicates no error. ippNullPtrErr Indicates an
//                          error when least one of the pointers pSrcY,
//                          pDstAudioOut, pVBuffer, or pVPosition is NULL.
//                          Audio Coding Functions 10 10-105
//    ippStsBadArgErr       Indicates an error when at least one of the
//                          specified pointers is NULL, or the value of mode
//                          is less than 1 or more than 2, or when the value
//                          of pVPosition exceeds [0, 15].
//    ippStsErr             Indicates an unknown error.
//
//  Notes:
//    Because the PQMF bank contains memory, the MP3 application must maintain
//    two state variables in between calls to the primitive.
//    First, the application must preallocate for the PQMF computation
//    a workspace buffer of size 512 x Number of Channels. This buffer is
//    referenced by the pointer pVBuffer, and its elements should be
//    initialized to zero prior to the first call. During subsequent calls,
//    the pVBuffer input for the current call should contain the pVbuffer
//    output generated by the previous call. In addition to pVBuffer, the MP3
//    application must also initialize to zero and thereafter preserve
//    the value of the state variable pVPosition. The MP3 application should
//    modify the values contained in pVBuffer or pVPosition only during
//    decoder reset, and the reset values should always be zero.
*/
IPPAPI(IppStatus, ippsSynthPQMF_MP3_32s16s, (
  Ipp32s* pSrcY,
  Ipp16s* pDstAudioOut,
  Ipp32s* pVBuffer,
  int*    pVPosition,
  int     mode))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsUnpackADIFHeader_AAC
//
//  Purpose:
//    Gets the AAC ADIF format header.
//
//  Parameters:
//    ppBitStream           Double pointer to the current byte before the
//                          ADIF header.
//    pADIFHeader           Pointer to the IppACCADIFHeader structure.
//    pPrgCfgElt            Pointer to the IppAACPrgCfgElt structure. There
//                          must be prgCfgEltMax elements in the buffer.
//    prgCfgEltMax          Maximum program configure element number. Must
//                          be within the range of [1, 16].
//
//  Returns:
//    ippStsNoErr           Indicates no error. Audio Coding Functions 10 10-
//                          121
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pADIFHeader, pPrgCfgElt,
//                          or *ppBitStream is NULL.
//    ippStsAacPrgNumErr    Indicates an error when the decoded pADIFHeader->
//                          numPrgCfgElt > prgCfgEltMax, or prgCfgEltMax is
//                          outside the range of [1,IPP_AAC_MAX_ELT_NUM].
//
// Notes:
//    1. pADIFHeader->numPrgCfgElt is the number directly unpacked
//       from bitstream plus 1.
//    2. It is assumed that it is known how many IppAACPrgCfgElt
//       must be supported.
*/
IPPAPI(IppStatus, ippsUnpackADIFHeader_AAC,(Ipp8u **ppBitStream,
                    IppAACADIFHeader *pADIFHeader, IppAACPrgCfgElt *pPrgCfgElt,
                                                            int prgCfgEltMax ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodePrgCfgElt_AAC
//
//  Purpose:
//    Gets program configuration element from the input bitstream.
//
//  Parameters:
//    ppBitStream           Double pointer to the current byte after
//                          decoding the program configuration element.
//    pOffset               Pointer to the bit position in the byte pointed
//                          to by *ppBitStream. Valid within 0 to 7: 0
//                          stands for the most significant bit of the byte;
//                          7 stands for the least significant bit of the
//                          byte.
//    pPrgCfgElt            Pointer to IppAACPrgCfgElt structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, pPrgCfgElt, or *
//                          ppBitStream is NULL.
//    ippStsAacBitOffsetErr Indicates an error when pOffset is out of the
//                          range of [0,7].
*/
IPPAPI(IppStatus, ippsDecodePrgCfgElt_AAC,(Ipp8u **ppBitStream, int *pOffset,
                                                 IppAACPrgCfgElt *pPrgCfgElt ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsUnpackADTSFrameHeader_AAC
//
//  Purpose:
//    Gets ADTS frame header from the input bitstream.
//
//  Parameters:
//    ppBitStream           Double pointer to the current byte after
//                          unpacking the ADTS frame header.
//    pADTSFrameHeader      Pointer to the IppAACADTSFrameHeader structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pADTSFrameHeader, or
//                          *ppBitStream is NULL.
*/
IPPAPI(IppStatus, ippsUnpackADTSFrameHeader_AAC, (Ipp8u **ppBitStream,
                                                  IppAACADTSFrameHeader *pADTSFrameHeader))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeDatStrElt_AAC
//
//  Purpose:
//    Gets data stream element from the input bitstream.
//
//  Parameters:
//    ppBitStream           Double pointer to the current byte.
//    pOffset               Pointer to the bit position in the byte pointed
//                          to by *ppBitStream. Valid within 0 to 7. 0
//                          stands for the most significant bit of the byte.
//                          7 stands for the least significant bit of the
//                          byte.
//    ppBitStream           Double pointer to the current byte after the
//                          decode data stream element.
//    pOffset               Pointer to the bit position in the byte pointed
//                          to by *ppBitStream. Valid within 0 to 7. 0
//                          stands for the most significant bit of the byte.
//                          7 stands for the least significant bit of the
//                          byte.
//    pDataTag              Pointer to element_instance_tag. See Table 6.20
//                          of ISO/IEC 13818-7:1997. pDataCn Pointer to the
//                          value of data length in bytes.
//    pDstDataElt           Pointer to the data stream buffer that contains
//                          the data stream extracted from the input
//                          bitstream. There are 512 elements in the buffer
//                          pointed to by pDstDataElt.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, *ppBitStream,
//                          pDataTag, pDataCnt, or pDstDataElt is NULL.
//    ippStsAacBitOffsetErr Indicates an error when *pOffset is out of range
//                          [0,7].
*/
IPPAPI(IppStatus, ippsDecodeDatStrElt_AAC,(Ipp8u **ppBitStream, int *pOffset,
                            int *pDataTag, int *pDataCnt, Ipp8u *pDstDataElt ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeFillElt_AAC
//
//  Purpose:
//    Gets the fill element from the input bitstream.
//
//  Parameters:
//    ppBitStream           Pointer to the pointer to the current byte after
//                          the decode fill element.
//    pOffset               Pointer to the bit position in the byte pointed
//                          to by *ppBitStream. Valid within 0 to 7. 0
//                          stands for the most significant bit of the byte.
//                          7 stands for the least significant bit of the
//                          byte.
//    pFillCnt              Pointer to the value of the length of total fill
//                          data in bytes.
//    pDstFillElt           Pointer to the fill data buffer whose length
//                          must be equal to or greater than 270.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, pFillCnt, or
//                          pDstFillElt is NULL.
//    ippStsAacBitOffsetErr Indicates an error when *pOffset is out of the
//                          range of [0,7].
*/
IPPAPI(IppStatus, ippsDecodeFillElt_AAC,(Ipp8u **ppBitStream, int *pOffset,
                                           int *pFillCnt, Ipp8u *pDstFillElt ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeChanPairElt_AAC
//
//  Purpose:
//    Gets channel_pair_element from the input bitstream.
//
//  Parameters:
//    ppBitStream           Double pointer to the current byte after
//                          decoding the channel pair element.
//    pOffset               Pointer to the bit position in the byte pointed
//                          to by *ppBitStream. Valid within 0 to 7: 0
//                          stands for the most significant bit of the byte;
//                          7 stands for the least significant bit of the
//                          byte.
//    pIcsInfo              Pointer to IppAACIcsInfo structure. If pIcsInfo->
//                          predDataPres = 0, set pIcsInfo->predReset = 0.
//                          Only the first pIcsInfo->numWinGrp elements in
//                          pIcsInfo-> pWinGrpLen are meaningful. You should
//                          not change some members of the structure, as
//                          shown in Table 10-5.
//    pChanPairElt          Pointer to IppAACChanPairElt structure. You
//                          should not change some members of the structure,
//                          as shown in Table 10-5.
//    predSfbMax            Maximum prediction scale factor bands. For LC
//                          profile, set predSfbMax = 0.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, *ppBitStream,
//                          pIcsInfo, or pChanPairElt is NULL.
//    ippStsAacBitOffsetErr Indicates an error when pOffset is out of the
//                          range of [0,7].
//    ippStsAacMaxSfbErr    Indicates an error when pIcsInfo->maxSfb decoded
//                          from bitstream is greater than IPP_AAC_MAX_SFB,
//                          the maximum scale factor band for all sampling
//                          frequencies.
//    ippStsAacPredSfbErr   Indicates an error when predSfbMax is out of
//                          the range of [0, IPP_AAC_PRED_SFB_MAX].
*/
IPPAPI(IppStatus, ippsDecodeChanPairElt_AAC, (Ipp8u             **ppBitStream,
                                              int               *pOffset,
                                              IppAACIcsInfo     *pIcsInfo,
                                              IppAACChanPairElt *pChanPairElt,
                                              int predSfbMax))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsNoiselessDecoder_LC_AAC
//
//  Purpose:
//    Decodes all data for one channel.
//
//  Parameters:
//    ppBitStream           Double pointers to bitstream buffer.
//    pOffset               Pointer to the offset in one byte.
//    pChanInfo             Pointer to the channel information.
//                          IppAACChanInfo structure. Denotes pIcsInfo as
//                          pChanInfo->pIcsInfo as shown in Table 10-6.
//    commonWin             Common window indicator.
//    pDstScalefactor       Pointer to the scalefactor or intensity position
//                          buffer. Buffer length is more than or equal to
//                          120. Only maxSfb elements are stored for each
//                          group. There is no space between sequence groups.
//    pDstQuantizedSpectralCoef Pointer to the quantized spectral
//                          coefficients data. For short block, the
//                          coefficients are interleaved by scale factor
//                          window bands in each group. Buffer length is
//                          more than or equal to 1024.
//    pDstSfbCb             Pointer to the scale factor band codebook.
//                          Buffer length must be more than or equal to 120.
//                          Store maxSfb elements for each group. There is
//                          no space between the sequence groups.
//    pDstTnsFiltCoef       Pointer to TNS coefficients. Buffer length must
//                          be more than or equal to 60. The store sequence
//                          is TNS order elements for each filter for each
//                          window. The elements are not changed if the
//                          corresponding TNS order is zero.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers ppBitStream, pOffset, pChanInfo,
//                          pDstScalefactor, pDstQuantizedSpectralCoef,
//                          pDstSfbCb, pDstTnsFiltCoef, pChanInfo->pIcsInfo,
//                          or *ppBitStream is NULL.
//    ippStsAacBitOffsetErr Indicates an error when pOffset is out of range
//                          [0,7].
//    ippStsAacComWinErr    Indicates an error when commonWin exceeds [0,1].
//    ippStsAacSmplRateIdxErr Indicates an error when pChanInfo->
//                          samplingRateIndex exceeds [0,11].
//    ippStsAacPredSfbErr   Indicates an error when pChanInfo->predSfbMax is
//                          not equal to 0.
//    ippStsAacMaxSfbErr    Indicates an error when pChanInfo->pIcsInfo->
//                          maxSfb > pChanInfo->numSwb.
//    ippStsAacSectCbErr    Indicates an error when the codebook pointed to
//                          by pChanInfo->pSectCb is illegal or when (
//                          pChanInfo->pSectCb)==12, 13. pTnsRegionLen As
//                          output. Pointer to the length of the region in
//                          units of scale factor bands to which one filter
//                          is applied in each window. pTnsFiltOrder As
//                          output. Pointer to the order of the temporal
//                          noise shaping filter applied to each window.
//                          pTnsDirection As output. Pointer to the token
//                          that indicates whether the filter is applied in
//                          the upward or downward direction. 0 stands for
//                          upward and 1 for downward. pIcsInfo As input if
//                          commonWin == 1. As output if commonWin == 0. If
//                          pIcsInfo->predDataPres == 0, set pIcsInfo->
//                          predReset = 0. Only the first pIcsInfo->
//                          numWinGrp elements in pIcsInfo-> pWinGrpLen are
//                          meaningful. Under specific conditions, some
//                          members of the structure must remain unchanged.
//    ippStsAacPlsDataErr   Indicates an error when the pChanInfo->pIcsInfo->
//                          winSequence indicates a short sequence and
//                          pChanInfo->pulsePres indicates pulse data present
//                          . The start scale factor band for pulse data >=
//                          pChanInfo->numSwb, or pulse data position offset
//                          >= winLen.
//    ippStsAacGainCtrErr   Indicates an error when pChanInfo->
//                          gainControlPres is decoded as 1, which means
//                          that gain control data is present. Gain control
//                          data is not currently supported.
//    ippStsAacCoefValErr   Indicates an error when the quantized
//                          coefficients value pointed to by pDstCoef
//                          exceeds range [-8191, 8191].
//
//  Notes:
//    User must set pChanInfo->samplingRateIndex, predSfbMax, pIcsInfo,
//    before calling this function.
*/
IPPAPI(IppStatus, ippsNoiselessDecoder_LC_AAC,(Ipp8u **ppBitStream,
                        int *pOffset, int commonWin, IppAACChanInfo *pChanInfo,
                    Ipp16s *pDstScalefactor, Ipp32s *pDstQuantizedSpectralCoef,
                                    Ipp8u *pDstSfbCb, Ipp8s *pDstTnsFiltCoef ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsQuantInv_AAC_32s_I
//
//  Purpose:
//    Performs inverse quantization of Huffman symbols for current channel
//    inplace.
//
//  Parameters:
//    pSrcDstSpectralCoef   On input, pointer to the input quantized
//                          coefficients. For short block the coefficients
//                          are interleaved by scale factor window bands in
//                          each group. Buffer length must be more than or
//                          equal to 1024. On output, pointer to the
//                          destination inverse quantized coefficient in Q13.
//                          18 format. For short block, the coefficients are
//                          interleaved by scale factor window bands in each
//                          group. Buffer length must be more than or equal
//                          to 1024. The maximum error of output.
//                          pSrcDstSpectralCoef[i] is listed in Table 10-7.
//    pScalefactor          Pointer to the scalefactor buffer. Buffer length
//                          must be more than or equal to 120.
//    numWinGrp             Group number.
//    pWinGrpLen            Pointer to the number of windows in each group.
//                          Buffer length must be more than or equal to 8.
//    maxSfb                Maximal scale factor bands number for the
//                          current block.
//    pSfbCb                Pointer to the scale factor band codebook,
//                          buffer length must be more than or equal to 120.
//                          Only maxSfb elements for each group are
//                          meaningful. There are no spaces between the
//                          sequence groups.
//    samplingRateIndex     Sampling rate index. Valid within [0, 11]. See
//                          Table 6.5 of ISO/IEC 13818-7:1997.
//    winLen                Data number in one window.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacSmplRateIdxErr Indicates an error when pChanInfo->
//                          samplingRateIndex exceeds [0, 11].
//    ippStsAacMaxSfbErr    Indicates an error when maxSfb exceeds [0,
//                          IPP_AAC_MAX_SFB].
//    ippStsAacWinGrpErr    Indicates an error when numWinGrp exceeds [0, 8]
//                          for long window or is not equal to 1 for short
//                          window.
//    ippStsAacWinLenErr    Indicates an error when winLen is not equal to
//                          128 or 1024;
//    ippStsAacCoefValErr   Indicates an error when the quantized
//                          coefficients value pointed to by
//                          pSrcDstSpectralCoef exceeds [-8191,8191].
*/
IPPAPI(IppStatus, ippsQuantInv_AAC_32s_I,(Ipp32s *pSrcDstSpectralCoef,
                                     const Ipp16s *pScalefactor, int numWinGrp,
                        const int *pWinGrpLen, int maxSfb, const Ipp8u *pSfbCb,
                                           int samplingRateIndex, int winLen ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeMsStereo_AAC_32s_I
//
//  Purpose:
//    Processes mid-side (MS) stereo for pair channels in-place.
//
//  Parameters:
//    pSrcDstL              On input, pointer to left channel data in Q13.18
//                          format. For short block, the coefficients are
//                          interleaved by scale factor window bands in each
//                          group. Buffer length must be more than or equal
//                          to 1024. On output, pointer to left channel data
//                          in Q13.18 format. For short blocks, the
//                          coefficients are interleaved by scale factor
//                          window bands in each group. Buffer length must
//                          be more than or equal to 1024.
//    pSrcDstR              On input, pointer to right channel data in Q13.
//                          18 format. For short block, the coefficients are
//                          interleaved by scale factor window bands in each
//                          group. Buffer length must be more than or equal
//                          to 1024. On output, pointer to right channel
//                          data in Q13.18 format. For short blocks, the
//                          coefficients are interleaved by scale factor
//                          window bands in each group. Buffer length must
//                          be more than or equal to 1024.
//    msMaskPres            MS stereo mask flag: - 0: MS off; - 1: MS on; - 2:
//                          MS all bands on.
//    pMsUsed               Pointer to the MS Stereo flag buffer. Buffer
//                          length must be more than or equal to 120.
//                          pSfbCbPointer Pointer to the scale factor band
//                          codebook, buffer length must be more than or
//                          equal to 120. Store maxSfb elements for each
//                          group.There is no space between the sequence
//                          groups.
//    numWinGrp             Group number.
//    pWinGrpLen            Pointer to the number of windows in each group.
//                          Buffer length must be more than or equal to 8.
//    maxSfb                Maximal scale factor bands number for the
//                          current block.
//    samplingRateIndex     Sampling rate index. Valid within [0, 11]. See
//                          Table 6.5 of ISO/IEC 13818-7:1997.
//    winLen                Data number in one window.
//    pSrcDstR              Pointer to right channel data in Q13.18 format.
//                          For short blocks, the coefficients are
//                          interleaved by scale factor window bands in each
//                          group. Buffer length must be more than or equal
//                          to 1024.
//    pSfbCb                Pointer to the scale factor band codebook. If
//                          invert_intensity (group, sfb) = -1, and if
//                          *pSfbCb = INTERITY_HCB, let
//                          *pSfbCb = INTERITY_HCB2.
//                          If *pSfbCb = INTERITY_HCB2, let
//                          *pSfbCb = INTERITY_HCB. Buffer length must be more
//                          than or equal to 120. Store maxSfb elements for
//                          each group. There is no space between the
//                          sequence groups.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacMaxSfbErr    Indicates an error when the coefficient index
//                          calculated from samplingFreqIndex and maxSfb
//                          exceeds winLen in each window.
//    ippStsAacSamplRateIdxErr Indicates an error when pChanInfor->
//                          samplingRateIndex exceeds [0,11].
//    ippStsAacWinGrpErr    Indicates an error when numWinGrp exceeds [0,8]
//                          for long window or is not equal to 1 for short
//                          window.
//    ippStsAacWinLenErr    Indicates an error when winLen is not equal 128
//                          or 1024.
//    ippStsStereoMaskErr   Indicates an error when the stereo mask flag is
//                          not equal 1 or 2.
//
// Notes:
//    Input and output data are in interleaving mode, only for CPE.
*/
IPPAPI(IppStatus, ippsDecodeMsStereo_AAC_32s_I,(Ipp32s *pSrcDstL,
                        Ipp32s *pSrcDstR, int msMaskPres, const Ipp8u *pMsUsed,
                           Ipp8u *pSfbCb, int numWinGrp, const int *pWinGrpLen,
                               int maxSfb, int samplingRateIndex, int winLen ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeIsStereo_AAC_32s
//
//  Purpose:
//    Processes intensity stereo for pair channels.
//
//  Parameters:
//    pSrcL                 Pointer to left channel data in Q13.18 format.
//                          For short block, the coefficients are
//                          interleaved by scale factor window bands in each
//                          group. Buffer length must be more than or equal
//                          to 1024.
//    pDstR                 Pointer to right channel data in Q13.18 format.
//                          For short block, the coefficients are
//                          interleaved by scale factor window bands in each
//                          group. Buffer length must be more than or equal
//                          to 1024.
//    pScalefactor          Pointer to the scalefactor buffer. Buffer length
//                          must be more than or equal to 120.
//    pSfbCb                Pointer to the scale factor band codebook,
//                          buffer length must be more than or equal to 120.
//                          Store maxSfb elements for each group.There is no
//                          space between the sequence groups. Respective
//                          values of pSfbCb[sfb] equal to 1, -1, or 0
//                          indicate the intensity stereo mode, that is,
//                          direct, inverse, or none.
//    numWinGrp             Group number.
//    pWinGrpLen            Pointer to the number of windows in each group.
//                          Buffer length must be more than or equal to 8.
//    maxSfbMax             Maximal scale factor bands number for
//                          the current block.
//    samplingRateIndex     Sampling rate index. Valid within [0, 11]. See
//                          Table 6.5 of ISO/IEC 13818-7:1997.
//    winLen                Data number in one window.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacMaxSfbErr    Indicates an error when the coefficient index
//                          calculated from samplingFreqIndex and maxSfb
//                          exceeds winLen in each window.
//    ippStsAacSamplRateIdxErr Indicates an error when pChanInfor->
//                          samplingRateIndex exceeds [0,11].
*/
IPPAPI(IppStatus, ippsDecodeIsStereo_AAC_32s,(const Ipp32s *pSrcL,
                                     Ipp32s *pDstR, const Ipp16s *pScalefactor,
                     const Ipp8u *pSfbCb, int numWinGrp, const int *pWinGrpLen,
                               int maxSfb, int samplingRateIndex, int winLen ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDeinterleaveSpectrum_AAC_32s
//
//  Purpose:
//    Deinterleaves the coefficients for short block.
//
//  Parameters:
//    pSrc                  Pointer to source coefficients buffer. The
//                          coefficients are interleaved by scale factor
//                          window bands in each group. Buffer length must
//                          be more than or equal to 1024.
//    pDst                  Pointer to the output of coefficients. Data
//                          sequence is ordered in pDst[w*128+sfb*sfbWidth[
//                          sfb]+i], where w is window index, sfb is scale
//                          factor band index, sfbWidth is the scale factor
//                          band width table, i is the index within scale
//                          factor band. Buffer length must be more than or
//                          equal to 1024.
//    numWinGrp             Group number.
//    pWinGrpLen            Pointer to the number of windows in each group.
//                          Buffer length must be more than or equal to 8.
//    maxSfb                Maximal scale factor bands number for
//                          the current block.
//    samplingRateIndex     Sampling rate index. Valid in [0, 11]. See Table
//                          6.5 of ISO/IEC 13818-7:1997.
//    winLen                Data number in one window.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacMaxSfbErr    Indicates an error when the coefficient index
//                          calculated from samplingFreqIndex and maxSfb
//                          exceeds winLen in each window.
//    ippStsAacSamplRateIdxErr Indicates an error when pChanInfor->
//                          samplingRateIndex exceeds [0,11].
//    ippStsAacWinGrpErr    Indicates an error when numWinGrp exceeds [0,8].
//    ippStsAacWinLenErr    Indicates an error when winLen is not equal to
//                          128.
*/
IPPAPI(IppStatus, ippsDeinterleaveSpectrum_AAC_32s,(const Ipp32s *pSrc,
                            Ipp32s *pDst, int numWinGrp, const int *pWinGrpLen,
                               int maxSfb, int samplingRateIndex, int winLen ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeTNS_AAC_32s_I
//
//  Purpose:
//    Decodes for Temporal Noise Shaping in-place.
//
//  Parameters:
//    pSrcDstSpectralCoefs  On input, pointer to the input spectral
//                          coefficients to be filtered by the all-pole
//                          filters in Q13.18 format. There are 1024
//                          elements in the buffer pointed to by
//                          pSrcDstSpectralCoefs. On output, pointer to the
//                          output spectral coefficients after filtering by
//                          the all-pole filters in Q13.18 format.
//    pTnsNumFilt           Pointer to the number of noise shaping filters
//                          used for each window of the current frame. There
//                          are 8 elements in the buffer pointed to by
//    pTnsNumFilt           which are arranged as follows:pTnsNumFilt[w]:
//                          the number of noise shaping filters used for
//                          window w, w = 0 to numWin-1.
//    pTnsRegionLen         Pointer to the length of the region in units of
//                          scale factor bands to which one filter is
//                          applied in each window of the current frame.
//                          There are 8 elements in the buffer pointed to by
//                          pTnsRegionLen, which are arranged as follows:
//                          pTnsRegionLen[i]: the length of the region to
//                          which filter filt is applied in window w w = 0
//                          to numWin-1, filt=0 to pTnsNumFilt[w]-1.
//    pTnsFiltOrder         Pointer to the order of one noise shaping filter
//                          applied to each window of the current frame.
//                          There are 8 elements in the buffer pointed to by
//                          pTnsFiltOrder, which are arranged as follows:
//                          pTnsFiltOrder[i]: the order of one noise shaping
//                          filter filt, which is applied to window w w = 0
//                          to numWin-1, filt=0 to pTnsNumFilt[w]-1.
//    pTnsFiltCoefRes       Pointer to the resolution of 3 bits or 4 bits of
//                          the transmitted filter coefficients for each
//                          window of the current frame. There are 8
//                          elements in the buffer pointed to by
//                          pTnsFiltCoefRes, which are arranged as follows:
//                          pTnsFiltCoefRes[w]: the resolution of the
//                          transmitted filter coefficients for window w, w
//                          = 0 to numWin-1.
//    pTnsFiltCoef          Pointer to the coefficients of one noise shaping
//                          filter applied to each window of the current
//                          frame. There are 60 elements in the buffer
//                          pointed to by pTnsFiltCoef, which are arranged
//                          as follows: pTnsFiltCoef[i], pTnsFiltCoef[i+1],
//                          ..., pTnsFiltCoef[i+order-1]: the coefficients of
//                          one noise shaping filter filt, which is applied
//                          to window w. The order is the same as that of
//                          the noise shaping filter filt as applied to
//                          window w, w = 0 to numWin-1, filt=0 to
//                          pTnsNumFilt[w]-1. For example, pTnsFiltCoef[0],
//                          pTnsFiltCoef[1], ..., pTnsFiltCoef[order0-1] are
//                          the coefficients of the noise shaping filter 0,
//                          which is applied to window 0, if present. If so,
//                          pTnsFiltCoef[order0], pTnsFiltCoef[order0+1], ...,
//                          pTnsFiltCoef[order0+order1-1] are the
//                          coefficients of the noise shaping filter 1
//                          applied to window 0, if present, and so on.
//                          order0 is the same as that of the noise shaping
//                          filter 0 applied to window 0, and order1 is the
//                          order of the noise shaping filter 1 applied to
//                          window 0. After window 0 is processed, process
//                          window 1, then window 2 until all numWin windows
//                          are processed.
//    pTnsDirection         Pointer to the token that indicates whether the
//                          filter is applied in the upward or downward
//                          direction. 0 stands for upward and 1 for downward
//                          . There are 8 elements in the buffer pointed to
//                          by pTnsDirection which are arranged as follows:
//                          pTnsDirection[i]: the token indicating whether
//                          the filter filt is applied in upward or downward
//                          direction to window w w = 0 to numWin-1, filt=0
//                          to pTnsNumFilt[w]-1.
//    maxSfb                Number of scale factor bands transmitted per
//                          window group of the current frame.
//    profile               Profile index from Table 7.1 in ISO/IEC 13818-7:
//                          1997.
//    samplingRateIndex     Index indicating the sampling rate of the
//                          current frame.
//    winLen                Data number in one window.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL. IppStsTnsProfielErr Indicates
//                          an error when profile != 1.
//    ippStsAacTnsNumFiltErr Indicates an error when a data error occurs:
//                          for a short window sequence pTnsNumFilt[w]
//                          exceeds [0,1]; Table 10-8 Computation Error List
//                          for pSrcDstSpectralCoefs MAX(error(
//                          pSrcDstSpectralCoefs[i])) Condition 4095 8 ==
//                          numWin 32767 1 == numWin NOTE. This function
//                          supports LC profile only. 10-142 10 Intel
//                          Integrated Performance Primitives Reference
//                          Manual: Volume 1 for a long window sequence,
//                          pTnsNumFilt[w] exceeds [0,3].
//    ippStsAacTnsLenErr    Indicates an error when pTnsRegionLen exceeds
//                          [0, numSwb].
//    ippStsAacTnsOrderErr  Indicates an error when a data error occurs: for
//                          a short window sequence, pTnsFiltOrder exceeds
//                          [0,7]; for a long window sequence, pTnsFiltOrder
//                          exceeds [0,12].
//    ippStsAacTnsCoefResErr Indicates an error when pTnsFiltCoefRes[w]
//                          exceeds [3, 4].
//    ippStsAacTnsCoefErr   Indicates an error when *pTnsFiltCoef exceeds
//                          [-8, 7].
//    ippStsAacTnsDirectErr Indicates an error when *pTnsDirection exceeds
//                          [0, 1].
//
// Notes:
//    Input/Output data(pSrcDstSpectralCoefs[]) are in Q3.
*/
IPPAPI(IppStatus, ippsDecodeTNS_AAC_32s_I,(Ipp32s *pSrcDstSpectralCoefs,
                              const int *pTnsNumFilt, const int *pTnsRegionLen,
                          const int *pTnsFiltOrder, const int *pTnsFiltCoefRes,
                           const Ipp8s *pTnsFiltCoef, const int *pTnsDirection,
                  int maxSfb, int profile, int samplingRateIndex, int winLen ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInv_AAC_32s16s
//
//  Purpose:
//    Maps time-frequency domain signal into time domain and generates 1024
//    reconstructed 16-bit signed little-endian PCM samples.
//
//  Parameters:
//    pSrcSpectralCoefs     Pointer to the input time-frequency domain
//                          samples in Q13.18 format. There are 1024
//                          elements in the buffer pointed to by
//                          pSrcSpectralCoefs.
//    pSrcDstOverlapAddBuf  Pointer to the overlap-add buffer that contains
//                          the second half of the previous block windowed
//                          sequence in Q13.18. There are 1024 elements in
//                          this buffer.
//    winSequence           Flag that indicates which window sequence is
//                          used for current block.
//    winShape              Flag that indicates which window function is
//                          selected for current block.
//    prevWinShape          Flag that indicates which window function is
//                          selected for previous block.
//    pcmMode               Flag that indicates whether the PCM audio output
//                          is interleaved, that is has the pattern LRLRLR...
//                          or not. 1 stands for not interleaved. 2 stands
//                          for interleaved
//    pDstPcmAudioOut       Pointer to the output 1024 reconstructed 16-bit
//                          signed little-endian PCM samples in Q15,
//                          interleaved, if needed. The maximum computation
//                          error for pDstPcmAudioOut is less than 1 for
//                          each vector element. The total quadratic error
//                          for the vector is less than 96.
//    pSrcDstOverlapAddBuf  Pointer to the overlap-add buffer which contains
//                          the second half of the current block windowed
//                          sequence in Q13.18. The maximum computation
//                          error for pDstPcmAudioOut is less than 4 for
//                          each vector element. The total quadratic error
//                          for the vector is less than 1536.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsAacWinSeqErr    Indicates an error when winSequence exceeds [0,3].
//    ippStsAacWinShapeErr  Indicates an error when winShape or prevWinShape
//                          exceeds [0,1].
//    ippStsAacPcmModeErr   Indicates an error when pcmMode exceeds [1,2].
//
// Notes:
//    Input data (pSrcSpectralCoefs[]) is in Q = _IPP_AAC_FB_Q;
//    data (pSrcDstOverlapAdd[]) is in Q = _IPP_AAC_FB_Q.
*/
IPPAPI(IppStatus, ippsMDCTInv_AAC_32s16s,(Ipp32s *pSrcSpectralCoefs,
                         Ipp16s *pDstPcmAudioOut, Ipp32s *pSrcDstOverlapAddBuf,
                int winSequence, int winShape, int prevWinShape, int pcmMode ))

IPPAPI(IppStatus, ippsMDCTInv_AAC_32s_I,(Ipp32s *tst_SrcDst, Ipp32s *tst_OverlapBuf,
       int winSeq, int winShape, int prewinShape, int len))

IPPAPI(IppStatus, ippsMDCTFwd_AAC_32s_I,(Ipp32s *tst_SrcDst, int winSeq, int winShape,
       int prewinShape, int len))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeMainHeader_AAC
//
//  Purpose:
//    Gets main header information and main layer information from bit stream.
//
//  Parameters:
//    ppBitStream           Double pointer to bitstream buffer. *ppBitStream
//                          will be updated after decoding.
//    pOffset               Pointer to the offset in one byte. *pOffset will
//                          be updated after decoding.
//    channelNum            Number of channels.
//    monoStereoFlag        Current frame has mono and stereo layers.
//    pAACMainHeader        Pointer to the main element header.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacBitOffsetErr Indicates an error when pOffset exceeds [0,7].
//    ippStsAacChanErr      Indicates an error when channelNum exceeds [1,2].
//    ippStsAacMonoStereoErr Indicates an error when monoStereoFlag exceeds
//                          [0,1].
*/
IPPAPI(IppStatus, ippsDecodeMainHeader_AAC,(Ipp8u **ppBitStream,
                int *pOffset, IppAACMainHeader *pAACMainHeader, int channelNum,
                                                          int monoStereoFlag ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeExtensionHeader_AAC
//
//  Purpose:
//    Gets extension header information and extension layer information from
//    bit stream.
//
//  Parameters:
//    ppBitStream           Double pointer to bitstream buffer. *ppBitStream
//                          will be updated after decoding.
//    pOffset               Pointer to the offset in one byte. *pOffset will
//                          be updated after decoding.
//    monoStereoFlag        Flag indicating that the current frame has mono
//                          and stereo layers.
//    thisLayerStereo       Flag indicating that the current layer is stereo.
//    monoLayerFlag         Flag indicating that the current frame has a
//                          mono layer.
//    preStereoMaxSfb       Previous stereo layer maxSfb.
//    hightstMonoMaxSfb     Last mono layer maxSfb.
//    winSequence           Window type, short or long.
//    pAACExtHeader         Pointer to the extension element header.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacBitOffsetErr Indicates an error when pOffset is out of the
//                          range of [0,7].
//    ippStsAacStereoLayerErr Indicates an error when thisLayerStereo
//                          exceeds [0,1].
//    ippStsAacMonoLayerErr Indicates an error when monoLayerFlag exceeds
//                          [0,1].
//    ippStsAacMaxSfbErr    Indicates an error when at least one of
//                          preStereoMaxSfb, hightstMonoMaxSfb or number of
//                          scale factor bands used in this layer exceeds
//                          [0,IPP_AAC_MAX_SFB].
//    ippStsAacMonoStereoErr Indicates an error when monoStereoFlag exceeds
//                          [0,1].
//    ippStsAacWinSeqErr    Indicates an error when winSequence exceeds
//                          [0,3].
//
*/
IPPAPI(IppStatus, ippsDecodeExtensionHeader_AAC,(Ipp8u **ppBitStream,
              int *pOffset, IppAACExtHeader *pAACExtHeader, int monoStereoFlag,
                   int thisLayerStereo, int monoLayerFlag, int preStereoMaxSfb,
                                      int hightstMonoMaxSfb, int winSequence ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodePNS_AAC_32s
//
//  Purpose:
//    Implements perceptual noise substitution (PNS) coding within
//    individual channel stream (ICS).
//
//  Parameters:
//    pSrcDstSpec           Pointer to spectrum coefficients for perceptual
//                          noise substitution (PNS).
//    pSrcDstLtpFlag        Pointer to long term predict (LTP) flag.
//    pSfbCb                Pointer to the scale factor codebook.
//    pScaleFactor          Pointer to the scalefactor value.
//    maxSfb                Number of scale factor bands used in this layer.
//    numWinGrp             Number of window groups.
//    pWinGrpLen            Pointer to the length of every window group.
//    samplingFreqIndex     Sampling frequency index.
//    winLen                Window length. 1024 for long windows, 128 for
//                          short windows.
//    pRandomSeed           Random seed for PNS.
//    pSrcDstSpec           Pointer to the output spectrum substituted by
//                          perceptual noise.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacMaxSfbErr    Indicates an error when maxSfb exceeds [0,
//                          IPP_AAC_MAX_SFB].
//    ippStsAacSmplRateIdxErr Indicates an error when pChanInfo->
//                          samplingRateIndex exceeds [0,12].
//    ippStsAacWinLenErr    Indicates an error when winLen is not equal to
//                          128 or 1024.
*/
IPPAPI(IppStatus, ippsDecodePNS_AAC_32s,(Ipp32s *pSrcDstSpec,
                      int *pSrcDstLtpFlag, Ipp8u *pSfbCb, Ipp16s *pScaleFactor,
             int maxSfb, int numWinGrp, int *pWinGrpLen, int samplingFreqIndex,
                                                int winLen, int *pRandomSeed ))

/* ///////////////////////////////////////////////////////////////////////////
// Name:
//    ippsDecodeMsPNS_AAC_32s
//
// Purpose:
//    Implements perceptual noise substitution coding within an ICS.
//
// Parameters:
//    pSrcDstSpec           Pointer to spectrum coefficients before PNS.
//    pSrcDstLtpFlag        Pointer to the LTP flag.
//    pSfbCb                Pointer to the scalefactor code book.
//    pScaleFactor          Pointer to the scalefactor coefficients.
//    maxSfb                Number of max scalefactor band.
//    numWinGrp             Number groups of windows.
//    pWinGrpLen            Pointer to the group length.
//    samplingFreqIndex     Sampling frequency index.
//    winLen                Length of windows.
//    pRandomSeed           Random seed.
//    channel               Index of current channel:
//                            0:  left;
//                            1:  right.
//    pMsUsed               Pointer to MS used buffer in CPE structure.
//    pNoiseState           Pointer to noise state buffer, which stores
//                          the left channel's noise random seed for
//                          every scalefactor band. When pMsUsed[sfb]==1,
//                          the content in this buffer will be used for
//                          right channel.
//
// Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacMaxSfbErr    Indicates an error when maxSfb exceeds [0,
//                          IPP_AAC_MAX_SFB].
//    ippStsAacWinGrpErr    Indicates an error when numWinGrp exceeds [0,8].
//    ippStsAacSmplRateIdxErr Indicates an error when samplingFreqIndex
//                          exceeds [0,16].
//    ippStsAacWinLenErr    Indicates an error when winLen is not equal to
//                          128 or 1024.
*/
IPPAPI(IppStatus, ippsDecodeMsPNS_AAC_32s,(Ipp32s *pSrcDstSpec,
                      int *pSrcDstLtpFlag, Ipp8u *pSfbCb, Ipp16s *pScaleFactor,
             int maxSfb, int numWinGrp, int *pWinGrpLen, int samplingFreqIndex,
             int winLen, int *pRandomSeed, int channel, Ipp8u *pMsUsed, int *pNoiseState ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsLongTermReconstruct_AAC_32s
//
//  Purpose:
//    Uses Long Term Reconstruct (LTR) to reduce signal redundancy between
//    successive coding frames.
//
//  Parameters:
//    pSrcDstSpec           Pointer to spectral coefficients for LTP.
//    pSrcEstSpec           Pointer to the frequency domain vector.
//    winSequence           Window type, long or short.
//    samplingFreqIndex     Sampling frequency index.
//    pLtpFlag              Pointer to the LTP flag.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacSmplRateIdxErr Indicates an error when pChanInfo->
//                          samplingRateIndex exceeds [0,12].
//    ippStsAacWinSeqErr    Indicates an error when winSequence exceeds
//                          [0,3].
*/
IPPAPI(IppStatus, ippsLongTermReconstruct_AAC_32s,(Ipp32s *pSrcEstSpec,
                           Ipp32s *pSrcDstSpec, int *pLtpFlag, int winSequence,
                                                       int samplingFreqIndex ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsEncodeTNS_AAC_32s_I
//
//  Purpose:
//    Performs reversion of TNS in the Long Term Reconstruct loop in-place.
//
//  Parameters:
//    pSrcDst               On input, pointer to the spectral coefficients
//                          for the TNS encoding operation. On output,
//                          pointer to the spectral coefficients after the
//                          TNS encoding operation.
//    pTnsNumFilt           Pointer to the number of TNS filters.
//    pTnsRegionLen         Pointer to the length of TNS filter.
//    pTnsFiltOrder         Pointer to the TNS filter order.
//    pTnsFiltCoefRes       Pointer to the TNS coefficient resolution flag.
//    pTnsFiltCoef          Pointer to the TNS filter coefficients.
//    pTnsDirection         Pointer to the TNS direction flag.
//    maxSfb                Maximum scale factor number.
//    profile               Audio profile.
//    samplingFreqIndex     Sampling frequency index.
//    winLen                Window length.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsTnsProfileErr   Indicates an error when profile != 1.
//    ippStsAacTnsNumFiltErr Indicates an error when *pTnsNumFilt exceeds
//                          [0, 1] for the short window sequence or [0, 3]
//                          for the long window sequence.
//    ippStsAacTnsLenErr    Indicates an error when *pTnsRegionLen exceeds
//                          [0, numSwb].
//    ippStsAacTnsOrderErr  Indicates an error when *pTnsFiltOrder exceeds
//                          [0, 7] for the short window sequence or [0, 12]
//                          for the long window sequence.
//    ippStsAacTnsCoefResErr Indicates an error when *pTnsFiltCoefRes
//                          exceeds [3, 4].
//    ippStsAacTnsCoefErr   Indicates an error when *pTnsFiltCoef exceeds
//                          [-8, 7].
//    ippStsAacTnsDirectErr Indicates an error when *pTnsDirection exceeds
//                          [0, 1].
//    ippStsAacSmplRateIdxErr Indicates an error when samplingRateIndex
//                          exceeds [0, 12].
//    ippStsAacWinLenErr    Indicates an error when winLen is not equal to
//                          128 or 1024.
//
// Notes:
//    Input/Output data(pSrcDstSpectralCoefs[]) are in Q3.
*/
IPPAPI(IppStatus, ippsEncodeTNS_AAC_32s_I,(Ipp32s *pSrcDstSpectralCoefs,
                              const int *pTnsNumFilt, const int *pTnsRegionLen,
                          const int *pTnsFiltOrder, const int *pTnsFiltCoefRes,
                           const Ipp8s *pTnsFiltCoef, const int *pTnsDirection,
                  int maxSfb, int profile, int samplingRateIndex, int winLen ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsLongTermPredict_AAC_32s
//
//  Purpose:
//    Gets the predicted time domain signals in the Long Term Reconstruct
//    (LTP) loop.
//
//  Parameters:
//    pSrcTimeSignal        Pointer to the temporal signals to be predicted
//                          in the temporary domain.
//    pDstEstTimeSignal     Pointer to the output of samples after LTP.
//    pAACLtpInfo           Pointer to the LTP information.
//    winSequence           Window type, short or long.
//    pDstEstTimeSignal     Pointer to the prediction output in time domain.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers is NULL.
//    ippStsAacWinSeqErr    Indicates an error when winSequence exceeds
//                          [0,3].
*/
IPPAPI(IppStatus, ippsLongTermPredict_AAC_32s,(Ipp32s *pSrcTimeSignal,
                         Ipp32s *pDstEstTimeSignal, IppAACLtpInfo *pAACLtpInfo,
                                                             int winSequence ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsNoiseLessDecode_AAC
//
//  Purpose:
//    Performs noiseless decoding.
//
//  Parameters:
//    ppBitStream           Double pointer to the bitstream to be parsed.
//                          *ppBitStream will be updated after decoding.
//    pOffset               Pointer to the offset in one byte. *pOffset will
//                          be updated after decoding.
//    pAACMainHeader        Pointer to main header information. Not used for
//                          scalable objects. When commonWin == 0 &&
//                          scaleFlag==0, you need to decode LTP information
//                          and save it in pAACMainHeader->pLtpInfo[].
//    pChanInfo             Pointer to channel information structure.
//                          windowSequence Window type, short or long.
//    maxSfb                Number of scale factor bands.
//    commonWin             Indicates if the channel pair uses the same ICS
//                          information.
//    scaleFlag             Flag indicating whether the scalable type is used.
//    audioObjectType       Audio object type indicator: 1 indicates the
//                          main type 2 indicates the LC type 6 indicates
//                          the scalable mode.
//    pDstScaleFactor       Pointer to the parsed scalefactor.
//    pDstQuantizedSpectralCoef Pointer to the quantized spectral
//                          coefficients after Huffman decoding.
//    pDstSfbCb             Pointer to the scale factor codebook index.
//    pDstTnsFiltCoef       Pointer to TNS filter coefficients. Not used for
//                          scalable objects.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacBitOffsetErr Indicates an error when pOffset is out of the
//                          range [0,7].
//    ippStsAacComWinErr    Indicates an error when commonWin exceeds [0,1].
//    ippStsAacMaxSfbErr    Indicates an error when maxSfb exceeds [0,
//                          IPP_AAC_MAX_SFB].
//    ippStsAacSmplRateIdxErr Indicates an error when pChanInfo->
//                          samplingRateIndex exceeds [0,11].
//    ippStsAacCoefValErr   Indicates an error when the quantized
//                          coefficients value pointed to by pDstCoef
//                          exceeds the range of [-8191,8191].
//
// Notes:
//    User must set pChanInfo,winSequence, maxSfb, commonWin and
//    scaleflag before calling this function; commonWin and scaleFlag
//    are 1 in condition of scaleable;
//    In comparison with AAC LC, only decode section data has little
//    changes when get dpcm_noise_nrg or hcod_sf[dpcm_noise_nrg]
//    information (all are stored in pDstScalefactor).
*/
IPPAPI(IppStatus, ippsNoiselessDecode_AAC,(Ipp8u **ppBitStream, int *pOffset,
                     IppAACMainHeader *pAACMainHeader, Ipp16s *pDstScalefactor,
                           Ipp32s *pDstQuantizedSpectralCoef, Ipp8u *pDstSfbCb,
                             Ipp8s *pDstTnsFiltCoef, IppAACChanInfo *pChanInfo,
                                    int winSequence, int maxSfb, int commonWin,
                                          int scaleFlag, int audioObjectType ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsLtpUpdate_AAC_32s
//
//  Purpose:
//    Performs required buffer update in the Long Term Reconstruct (LTP) loop.
//
//  Parameters:
//    pSpecVal              Pointer to spectral value after TNS decoder in
//                          LTP loop.
//    pLtpSaveBuf           Pointer to save buffer for LTP. Buffer length
//                          should be 3*frameLength. The value is saved for
//                          next frame.
//    winSequence           Window type:
//                            - 0 stands for long
//                            - 1 stands for long start
//                            - 2 stands for short
//                            - 3 stands for long stop.
//    winShape              KBD or SIN window shape.
//    preWinShape           Previous window shape.
//    pWorkBuf              Work buffer for LTP update, length of pWorkBuf
//                          should be at least 2048*3 = 6144 words.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacWinSeqErr    Indicates an error when winSequence exceeds [0,3].
//    ippStsAacWinShapeErr  Indicates an error when winShape or preWinShape
//                          exceeds [0,1].
*/
IPPAPI(IppStatus, ippsLtpUpdate_AAC_32s,(Ipp32s *pSpecVal,
                            Ipp32s *pLtpSaveBuf, int winSequence, int winShape,
                                           int preWinShape, Ipp32s *pWorkBuf ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwd_AAC_32s
//
//  Purpose:
//    Generates spectrum coefficient of PCM samples.
//
//  Parameters:
//    pSrc                  Pointer to temporal signals to do MDCT.
//    pDst                  Output of MDCT, the spectral coefficients of PCM
//                          samples.
//    pOverlapAdd           Pointer to overlap buffer. Not used for MPEG-4
//                          AAC decoding.
//    winSequence           Window sequence indicating if the block is long
//                          or short.
//    winShape              Current window shape.
//    preWinShape           Previous window shape.
//    pWindowedBuf          Work buffer for MDCT. Should be at least 2048
//                          words.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacWinSeqErr    Indicates an error when winSequence exceeds [0,3].
//    ippStsAacWinShapeErr  Indicates an error when preWinShape exceeds
//                          [0,1].
*/
IPPAPI(IppStatus, ippsMDCTFwd_AAC_32s,(Ipp32s *pSrc, Ipp32s *pDst,
                            Ipp32s *pOverlapAdd, int winSequence, int winShape,
                                       int preWinShape, Ipp32s *pWindowedBuf ))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsDecodeChanPairElt_MP4_AAC
//
//  Purpose:
//    Gets channel_pair_element from the input bitstream.
//
//  Parameters:
//    ppBitStream           Double pointer to the current byte.*ppBitStream
//                          will be updated after decoding.
//    pOffset               Pointer to the bit position in the byte pointed
//                          to by *ppBitStream. Valid within 0 to 7: 0
//                          stands for the most significant bit of the byte;
//                          7 stands for the least significant bit of the
//                          byte.
//    pIcsInfo              Pointer to IppAACIcsInfo structure.
//    pChanPairElt          Pointer to IppAACChanPairElt structure.
//    pAACMainHeader        Pointer to the main element header.
//    predSfbMax            Maximum prediction scale factor bands.
//    audioObjectType       Audio object type indicator: 1 indicates the
//                          main type 2 indicates the LC type 6 indicates
//                          the scalable mode.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          specified pointers is NULL.
//    ippStsAacBitOffsetErr Indicates an error when pOffset is out of the
//                          range of [0,7].
//    ippStsAacMaxSfbErr    Indicates an error when pIcsInfo->maxSfb decoded
//                          from bitstream is greater than IPP_AAC_MAX_SFB,
//                          the maximum scale factor band for all sampling
//                          frequencies.
*/
IPPAPI(IppStatus, ippsDecodeChanPairElt_MP4_AAC,(Ipp8u **ppBitStream, int *pOffset,
                            IppAACIcsInfo *pIcsInfo, IppAACChanPairElt *pChanPairElt,
                            IppAACMainHeader *pAACMainHeader, int predSfbMax,
                            int audioObjectType))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVLCDecodeEscBlock_MP3_1u16s
//
//  Purpose:
//    Parses the bitstream and decodes variable length code for MP3.
//
//  Parameters:
//    ppBitStream           Pointer to pointer to the current byte in the
//                          bitstream buffer. *ppBitStream is updated by the
//                          function.
//    pBitOffset            Pointer to the bit position in the byte pointed
//                          by *ppBitStream.
//                          *pBitOffset is updated by the function.
//    linbits               Length of escape sequence.
//    pData                 Pointer to the array of decoded values.
//    len                   Number of values to decode into array pData.
//    pVLCSpec              Pointer to VLCDecoder specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one or more pointers
//                          passed to the function is NULL.
//    ippStsVLCInputDataErr Indicates an error when incorrect input is used.
//                          For decode functions it can indicate that
//                          bitstream contains code that is not specified
//                          inside the used table.
//    ippStsBitOffsetErr    Indicates an error when *pBitOffset is less
//                          than 0 or more than 7.
//    ippStsContextMatchErr Indicate an error when pVLCSpec struct was not
//                          created by ippsVLCDecodeInit_32s or
//                          ippsVLCDecodeInitAlloc_32s functions.
*/
IPPAPI(IppStatus, ippsVLCDecodeEscBlock_MP3_1u16s,(Ipp8u **ppBitStream,
                                                   int *pBitOffset,
                                                   int linbits,
                                                   Ipp16s *pData,
                                                   int len,
                                                   const IppsVLCDecodeSpec_32s *pVLCSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVLCDecodeEscBlock_AAC_1u16s
//
//  Purpose:
//    Parses the bitstream and decodes variable length code for AAC.
//
//  Parameters:
//    ppBitStream           Pointer to pointer to the current byte in the
//                          bitstream buffer. *ppBitStream is updated by
/                           the function.
//    pBitOffset            Pointer to the bit position in the byte pointed
//                          by *ppBitStream.
//                          *pBitOffset is updated by the function.
//    pData                 Pointer to the array of decoded values.
//    len                   Number of values to decode into array pData.
//    pVLCSpec              Pointer to VLCDecoder specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one or more pointers
//                          passed to the function is NULL.
//    ippStsVLCInputDataErr Indicates an error when incorrect input is used.
//                          For decode functions it can indicate that
//                          bitstream contains code that is not specified
//                          inside the used table.
//    ippStsBitOffsetErr    Indicates an error when *pBitOffset is less
//                          than 0 or more than 7.
//    ippStsVLCAACEscCodeLengthErr Indicates an error when bitstream
//                          contains AAC-Esc code with the length more than
//                          21.
//    ippStsContextMatchErr Indicate an error when pVLCSpec struct was not
//                          created by ippsVLCDecodeInit_32s or
//                          ippsVLCDecodeInitAlloc_32s functions.
*/
IPPAPI(IppStatus, ippsVLCDecodeEscBlock_AAC_1u16s,(Ipp8u **ppBitStream,
                                                   int *pBitOffset,
                                                   Ipp16s *pData,
                                                   int len,
                                                   const IppsVLCDecodeSpec_32s *pVLCSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVLCEncodeEscBlock_MP3_16s1u
//
//  Purpose:
//    Encodes an array of values into destination bitstream in MP3 format
//    and advances bitstream pointer.
//
//  Parameters:
//    pInputData            Pointer to the array of source values.
//    len                   Size of values array pInputData.
//    linbits               Length of escape sequence.
//    ppBitStream           Pointer to pointer to the current byte in the
//                          bitstream buffer. *ppBitStream is updated by
//                          the function.
//    pBitOffset            Ppointer to the bit position in the byte pointed
//                          by *ppBitStream.
//                          *pBitOffset is updated by the function.
//    pVLCSpec              Pointer to VLCEncoder specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pointers to data
//                          arrays are NULL.
//    ippStsBitOffsetErr    Indicates an error when *pBitOffset is less
//                          than 0 or more than 7.
//    ippStsContextMatchErr Indicate an error when pVLCSpec struct was not
//                          created by ippsVLCEncodeInit_32s or
//                          ippsVLCEncodeInitAlloc_32s functions.
*/
IPPAPI(IppStatus, ippsVLCEncodeEscBlock_MP3_16s1u,(const Ipp16s *pInputData,
                                                   int len,
                                                   int linbits,
                                                   Ipp8u **ppBitStream,
                                                   int *pBitOffset,
                                                   const IppsVLCEncodeSpec_32s *pVLCSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVLCEncodeEscBlock_AAC_16s1u
//
//  Purpose:
//    Encodes an array of values into destination bitstream in AAC format
//    and advances bitstream pointer.
//
//  Parameters:
//    pInputData            Pointer to the array of source values.
//    len                   Size of values array pInputData.
//    ppBitStream           Pointer to pointer to the current byte in the
//                          bitstream buffer.
//                          *ppBitStream is updated by the function.
//    pBitOffset            Pointer to the bit position in the byte pointed
//                          by *ppBitStream.
//                          *pBitOffset is updated by the function.
//    pVLCSpec              Pointer to VLCEncoder specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pointers to data
//                          arrays are NULL.
//    ippStsBitOffsetErr    Indicates an error when *pBitOffset is less
//                          than 0 or more than 7.
//    ippStsContextMatchErr Indicate an error when pVLCSpec struct was not
//                          created by ippsVLCEncodeInit_32s or
//                          ippsVLCEncodeInitAlloc_32s functions.
*/
IPPAPI(IppStatus, ippsVLCEncodeEscBlock_AAC_16s1u,(const Ipp16s *pInputData,
                                                   int len,
                                                   Ipp8u **ppBitStream,
                                                   int *pBitOffset,
                                                   const IppsVLCEncodeSpec_32s *pVLCSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVLCCountEscBits_MP3_16s32s
//
//  Purpose:
//    Calculates the number of bits necessary for encoding in MP3 format.
//
//  Parameters:
//    pInputData            Pointer to the array of source values.
//    len                   Size of values array pInputData.
//    linbits               Length of escape sequence. pCounBits Pointer to
//                          calculated length in bits to encode pInputData.
//    pVLCSpec              Pointer to VLCEncoder specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pointers to data
//                          arrays are NULL.
//    ippStsContextMatchErr Indicate an error when pVLCSpec struct was not
//                          created by ippsVLCEncodeInit_32s or
//                          ippsVLCEncodeInitAlloc_32s functions.
*/
IPPAPI(IppStatus, ippsVLCCountEscBits_MP3_16s32s,(const Ipp16s *pInputData,
                                                  int len,
                                                  int linbits,
                                                  Ipp32s *pCountBits,
                                                  const IppsVLCEncodeSpec_32s *pVLCSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsVLCCountEscBits_AAC_16s32s
//
//  Purpose:
//    Calculates the number of bits necessary for encoding in AAC format.
//
//  Parameters:
//    pInputData            Pointer to the array of source values.
//    len                   Size of values array pInputData.
//    pCountBits            Pointer to calculated length in bits to encode
//                          pInputData.
//    pVLCSpec              Pointer to VLCEncoder specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when the pointers to data
//                          arrays are NULL.
//    ippStsContextMatchErr Indicate an error when pVLCSpec struct was not
//                          created by ippsVLCEncodeInit_32s or
//                          ippsVLCEncodeInitAlloc_32s functions.
*/
IPPAPI(IppStatus, ippsVLCCountEscBits_AAC_16s32s,(const Ipp16s *pInputData,
                                                  int len,
                                                  Ipp32s *pCountBits,
                                                  const IppsVLCEncodeSpec_32s *pVLCSpec))

/*******************************************************************/

/*
//  Name:       ippsVLCDecodeUTupleEscBlock_MP3_1u16s
//  Purpose:    decodes a len element encoded by VLC code from the source data
//              *ppBitStream with *pBitOffset bits offset and stores the result in
//              the destination *pData
//
//  Arguments:
//     ppBitStream                 Pointer to pointer to the current byte in the
//                                 bitstream buffer. *ppBitStream is updated by the function.
//     pBitOffset                  Pointer to the bit position in the byte pointed by
//                                 *ppBitStream. Valid within the range 0 to 7.
//                                 *pBitOffset is updated by the function.
//     linbits                     Length of escape sequence.
//     pData                       Pointer to the array of decoded values.
//     len                         Number of values to decode into array pData.
//     pVLCSpec                    pointer to VLCDecoder specification structure
//
//  Return:
//     ippStsNoErr                  Indicates no error.
//     ippStsNullPtrErr             Indicates an error when one or more pointers
//                                  passed to the function is NULL.
//     ippStsVLCInputDataErr        Indicates an error when incorrect input is used.
//                                  For decode functions it can indicate that bitstream
//                                  contains code that is not specified inside the used table.
//     ippStsBitOffsetErr           Indicate an error when offset less than 0 or more then 7.
//     ippStsContextMatchErr        Indicate an error when pVLCSpec struct was not created by
//                                  ippsVLCDecodeInit_32s or ippsVLCDecodeInitAlloc_32s functions.
//
*/

IPPAPI(IppStatus, ippsVLCDecodeUTupleEscBlock_MP3_1u16s,(Ipp8u **ppBitStream,
                                                   int *pBitOffset,
                                                   int linbits,
                                                   Ipp16s *pData,
                                                   int len,
                                                   const IppsVLCDecodeUTupleSpec_32s *pVLCSpec))

/*******************************************************************/

/*
//  Name:       ippsVLCDecodeUTupleEscBlock_AAC_1u16s
//  Purpose:    decodes a len element encoded by VLC code from the source data
//              *ppBitStream with *pBitOffset bits offset and stores the result in
//              the destination *pData
//
//  Arguments:
//     ppBitStream                 Pointer to pointer to the current byte in the
//                                 bitstream buffer. *ppBitStream is updated by the function.
//     pBitOffset                  Pointer to the bit position in the byte pointed by
//                                 *ppBitStream. Valid within the range 0 to 7.
//                                 *pBitOffset is updated by the function.
//     pData                       Pointer to the array of decoded values.
//     len                         Number of values to decode into array pData.
//     pVLCSpec                    pointer to VLCDecoder specification structure
//
//  Return:
//     ippStsNoErr                  Indicates no error.
//     ippStsNullPtrErr             Indicates an error when one or more pointers
//                                  passed to the function is NULL.
//     ippStsVLCInputDataErr        Indicates an error when incorrect input is used.
//                                  For decode functions it can indicate that bitstream
//                                  contains code that is not specified inside the used table.
//     ippStsVLCAACEscCodeLengthErr Indicates an error when bitstream contains AAC-Esc code
//                                  with the length more than 21.
//     ippStsBitOffsetErr           Indicate an error when offset less than 0 or more then 7.
//     ippStsContextMatchErr        Indicate an error when pVLCSpec struct was not created by
//                                  ippsVLCDecodeInit_32s or ippsVLCDecodeInitAlloc_32s functions.
//
*/

IPPAPI(IppStatus, ippsVLCDecodeUTupleEscBlock_AAC_1u16s,(Ipp8u **ppBitStream,
                                                   int *pBitOffset,
                                                   Ipp16s *pData,
                                                   int len,
                                                   const IppsVLCDecodeUTupleSpec_32s *pVLCSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPackFrameHeader_MP3
//
//  Purpose:
//    Packs the content of the frame header into the bitstream.
//
//  Parameters:
//    pSrcFrameHeader       Pointer to the IppMP3FrameHeader structure. This
//                          structure contains all the header information
//                          associated with the current frame. All structure
//                          fields must contain valid data upon function
//                          entry.
//    ppBitStream           Pointer to the encoded bitstream buffer - a
//                          double pointer to the first byte in the
//                          bitstream buffer intended to receive the packed
//                          frame header bits generated by this function.
//                          The frame header bits are sequentially written
//                          into the stream buffer starting from the bit
//                          indexed by the combination of byte pointer
//                          ppBitStream. The frame header bits
//                          are formatted according to the bitstream syntax
//                          given in ISO/IEC 11172-3.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSrcFrameHeader or
//                          ppBitStream is NULL.
*/
IPPAPI(IppStatus, ippsPackFrameHeader_MP3, (
    IppMP3FrameHeader*  pSrcFrameHeader,
    Ipp8u**             ppBitStream))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPackSideInfo_MP3
//
//  Purpose:
//    Packs the side information into the bitstream buffer.
//
//  Parameters:
//    pSrcSideInfo          Pointer to the IppMP3SideInfo structures. This
//                          should contain twice the channel number of
//                          elements. The order is the following: - granule 1
//                          , channel 1; - granule 1, channel 2; - granule 2,
//                          channel 1; - granule 2, channel 2. All fields of
//                          all set elements should contain valid data upon
//                          the function entry.
//    mainDataBegin         Negative bitstream offset, in bytes. The
//                          parameter value is typically the number of bytes
//                          remaining in the bit reservoir before the start
//                          of quantization for the current frame. When
//                          computing mainDataBegin, you should exclude the
//                          header and side information bytes. The side
//                          information formatter packs the 9-bit value of
//                          mainDataBegin into the main_data_begin field of
//                          the output bitstream.
//    privateBits           Depending on the number of channels, the
//                          function extracts the appropriate number of
//                          least significant bits from the parameter
//                          privateBits and packs them into the private_bits
//                          field of the output bitstream. The ISO/IEC 11172-3
//                          bitstream syntax reserves a channel-dependent
//                          number of application-specific (private) bits in
//                          the layer III bitstream audio data section
//                          immediately following the parameter
//                          main_data_begin. See ISO/IEC 11172-3:1993. For
//                          dualand single-channel streams, respectively,
//                          three and five bits are reserved.
//    pSrcScfsi             Pointer to the scale factor selection
//                          information table. This vector contains a set of
//                          binary flags that indicate whether scalefactors
//                          are shared across granules of a frame within
//                          predefined scale factor selection groups. For
//                          example, bands 0,1,2,3,4,5 form one group and
//                          bands 6,7,8,9,10 form the second group, as
//                          defined in ISO/IEC 11172-3.
//                          The vector is indexed as
//                          pDstScfsi[ch][scfsi_band], where:
//                          - ch is the channel index, 0 stands for
//                          channel 1, 1 stands for channel 2;
//                          - scfsi_band is the scale factor selection group
//                          number. Group 0 includes SFBs 0-5, group 1
//                          includes SFBs 6-10, group 2 includes SFBs 11-15,
//                          and group 3 includes SFBs 16-20.
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure. Only
//                          MPEG-1 (id = 1) is supported. Upon the function
//                          entry, the  structure fields id, mode, and layer
//                          should contain, respectively, the algorithm id
//                          (MPEG-1 or MPEG-2), the mono or stereo mode, and
//                          the MPEG layer specifier. All other pFrameHeader
//                          fields are ignored.
//    ppBitStream           Pointer to the encoded bitstream buffer. The
//                          parameter is a double pointer to the first byte
//                          in the bitstream buffer intended to receive the
//                          packed side information bits generated by this
//                          function. The side information bits are
//                          sequentially written into the stream buffer
//                          starting from the byte-aligned location
//                          referenced by *ppBitStream.
//    ppBitStream           Updated bitstream byte pointer. The parameter *
//                          ppBitStream points to the first available
//                          bitstream buffer byte immediately following the
//                          packed side information bits. The frame header
//                          bits are formatted according to the bitstream
//                          syntax given in ISO/IEC 11172-3:1993. Description
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSrcSideInfo,
//                          ppBitStream, pSrcScfsi, or pFrameHeader is NULL.
//    ippStsMP3FrameHeaderErr Indicates an error when
//                          pFrameHeader->id != IPP_MP3_ID_MPEG1
//                          pFrameHeader->id != IPP_MP3_ID_MPEG2
//                          pFrameHeader->mode exceeds [0, 3].
*/
IPPAPI(IppStatus, ippsPackSideInfo_MP3, (
    IppMP3SideInfo*     pSrcSideInfo,
    Ipp8u**             ppBitStream,
    int                 mainDataBegin,
    int                 privateBits,
    int*                pSrcScfsi,
    IppMP3FrameHeader*  pFrameHeader))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPackScalefactors_MP3_8s1u
//
//  Purpose:
//    Applies noiseless coding to scalefactors and packs output into
//    bitstream buffer.
//
//  Parameters:
//    pSrcScaleFactor       Pointer to a vector of scalefactors generated
//                          during the quantization process for one channel
//                          of one granule. Scale factor vector lengths
//                          depend on the block mode. Short block granule
//                          scale factor vectors contain 36 elements, or
//                          12 elements for each subblock. Long block
//                          granule scale factor vectors contain 21 elements.
//                          Thus short block scale factor vectors are indexed
//                          as follows: pSrcScaleFactor[sb*12+sfb], where
//                          - sb is the subblock index. 0 stands for subblock
//                          1, 1 stands for subblock 2, 2 stands for subblock
//                          3.
//                          - sfb is the scale factor band index (0-11).
//                          Long block scale factor vectors are indexed as
//                          follows:
//                          pSrcScaleFactor[sfb], where sfb is the scale
//                          factor band index (0-20).
//                          The associated side information for an individual
//                          granule/channel can be used to select the
//                          appropriate indexing scheme.
//    ppBitStream           Updated bitstream byte pointer. This parameter
//                          points to the first available bitstream buffer
//                          byte immediately following the bits generated by
//                          the scale factor Huffman encoder and
//                          sequentially written into the stream buffer. The
//                          scale factor bits are formatted according to the
//                          bitstream syntax given in ISO/IEC 11172-3.
//    pOffset               Updated bitstream bit pointer. The pOffset
//                          parameter indexes the next available bit in the
//                          next available byte referenced by the updated
//                          bitstream buffer byte pointer ppBitStream. This
//                          parameter is valid within the range of 0 to 7,
//                          where 0 corresponds to the most significant bit
//                          and 7 corresponds to the least significant bit.
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure for
//                          this frame. Upon the function entry, the
//                          structure fields id and modeExt should contain,
//                          respectively, the algorithm id (MPEG-1 or MPEG-2
//                          ) and the joint stereo coding commands generated
//                          by the psychoacoustic model. All other
//                          pFrameHeader fields are ignored. Only MPEG-1 (id
//                          = 1) is supported.
//    pSideInfo             Pointer to the IppMP3SideInfo structure for the
//                          current granule and channel. Upon function entry
//                          , the structure fields blockType, mixedBlock,
//                          and sfCompress should contain, respectively, the
//                          block type indicator start, short, or stop,
//                          filter bank mixed block analysis mode specifier,
//                          and scale factor bit allocation. All other *
//                          pSideInfo fields are ignored by the scale factor
//                          encoder.
//    pScfsi                Pointer to the scale factor selection
//                          information table that contains the set of
//                          binary flags that indicate whether scalefactors
//                          are shared across granules of a frame within the
//                          predefined scale factor selection groups. For
//                          example, bands 0,1,2,3,4,5 form one group and
//                          bands 6,7,8,9,10 form a second group (as defined
//                          in ISO/IEC 11172-3). The vector is indexed as
//                          follows: pScfsi[ch][scfsi_band], where - ch is
//                          the channel index. 0 stands for channel 1, 1
//                          stands for channel 2. - scfsi_band is the scale
//                          factor selection group number. Group 0 includes
//                          SFBs 0-5, group 1 includes SFBs 6-10, group 2
//                          includes SFBs 11-15, and group 3 includes SFBs
//                          16-20.
//    granule               Index of the current granule. 0 stands for
//                          granule 1, 1 stands for granule 2.
//    channel               Index of the current channel. 0 stands for
//                          channel 1, 1 stands for channel 2.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsMP3SideInfoErr  Indicates an error when
//                          pFrameHeader->id == IPP_MP3_ID_MPEG1 and
//                          pSideInfo->sfCompress exceeds [0..15];
//                          pFrameHeader->id == IPP_MP3_ID_MPEG2 and
//                          pSideInfo->sfCompress exceeds [0..511].
//    ippStsMP3FrameHeaderErr Indicates an error when pFrameHeader->id ==
//                          IPP_MP3_ID_MPEG2 and pFrameHeader->modeExt
//                          exceeds [0..3].
*/
IPPAPI(IppStatus, ippsPackScaleFactors_MP3_8s1u, (
    const Ipp8s*        pSrcScaleFactor,
    Ipp8u**             ppBitStream,
    int*                pOffset,
    IppMP3FrameHeader*  pFrameHeader,
    IppMP3SideInfo*     pSideInfo,
    int*                pScfsi,
    int                 granule,
    int                 channel))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsHuffmanEncode_MP3_32s1u
//
//  Purpose:
//    Applies lossless Huffman encoding to quantized samples and packs
//    output into bitstream buffer.
//
//  Parameters:
//    pSrcIx                Pointer to the quantized samples of a granule.
//                          The buffer length is 576. Depending on which
//                          type of joint coding has been applied, if any,
//                          the coefficient vector might be associated with
//                          either the L, R, M, S, and/or intensity channel
//                          of the quantized spectral data.
//    ppBitStream           Updated bitstream byte pointer. The parameter *
//                          ppBitStream points to the first available
//                          bitstream buffer byte immediately following the
//                          bits generated by the spectral coefficient
//                          Huffman encoder and sequentially written into
//                          the stream buffer. The Huffman symbol bits are
//                          formatted according to the bitstream syntax
//                          given in ISO/IEC 11172-3.
//    pOffset               Updated bitstream bit pointer. The pOffset
//                          parameter indexes the next available bit in the
//                          next available byte referenced by the updated
//                          bitstream buffer byte pointer ppBitStream. This
//                          parameter is valid within the range of 0 to 7,
//                          where 0 corresponds to the most significant bit
//                          and 7 corresponds to the least significant bit.
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure for
//                          this frame. The Huffman encoder uses the frame
//                          header id field in connection with the side
//                          information (as described below) to compute the
//                          Huffman table region boundaries for the big
//                          value spectral region. The Huffman encoder
//                          ignores all other frame header fields.Only
//                          MPEG-1 (id = 1) is supported.
//    pSideInfo             Pointer to the IppMP3SideInfo structure for the
//                          current granule and channel. The structure
//                          elements bigVals, pTableSelect[0]-[2], reg0Cnt,
//                          and reg1Cnt are used to control coding of
//                          spectral coefficients in the big value region.
//                          The structure element cnt1TabSel is used to
//                          select the appropriate Huffman table for the (-1,
//                          0,+1)-valued 4-tuples in the count1 region. For
//                          detailed descriptions of all side information
//                          elements, see the structure definition header
//                          file.
//    count1Len             The count1 region length specifier. Indicates
//                          the number of spectral samples for the current
//                          granule/channel above the big value region that
//                          can be combined into 4-tuples in which all
//                          elements are of magnitude less than or equal to 1.
//    hufSize               Huffman coding bit allocation specifier.
//                          Indicates the total number of bits that are
//                          required to represent the Huffman-encoded
//                          quantized spectral coefficients for the current
//                          granule/channel in both the bigvals and count1
//                          regions. Whenever necessary, this bit count
//                          should be augmented to include the number of
//                          bits required to manage the bit reservoir. For
//                          frames in which the reservoir has reached
//                          maximum capacity, the surplus bits are expended
//                          by padding with additional bits the Huffman
//                          representation of the spectral samples. The
//                          HufSize result returned by the function
//                          Quantize_MP3_32s_I reflects these padding
//                          requirements. That is, HufSize[i] is equal to
//                          the total of the number of bits required for
//                          Huffman symbols and the number of padding bits.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the specified
//                          pointers is NULL.
//    ippStsBadArgErr       Indicates an error when pOffset exceeds [0,7].
//    ippStsMP3SideInfoErr  Indicates an error when pSideInfo->bigVals*2>
//                          IPP_MP3_GRANULE_LEN (pSideInfo->reg0Cnt +
//                          pSideInfo->reg1Cnt + 2) >= 23, pSideInfo->
//                          cnt1TabSel exceeds [0,1], pSideInfo->pTableSelect
//                          [i] exceeds [0..31].
//    ippStsMP3FrameHeader  Indicates an error when
//                          pFrameHeader->id != IPP_MP3_ID_MPEG1
//                          pFrameHeader->layer != 1
//                          pFrameHeader->samplingFreq exceeds [0..2].
*/
IPPAPI(IppStatus, ippsHuffmanEncode_MP3_32s1u, (
    Ipp32s *pSrcIx,
    Ipp8u **ppBitStream,
    int *pOffset,
    IppMP3FrameHeader *pFrameHeader,
    IppMP3SideInfo *pSideInfo,
    int count1Len,
    int hufSize))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsBitReservoirInit_MP3
//
//  Purpose:
//    Initializes all elements of the bit reservoir state structure.
//
//  Parameters:
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure that
//                          contains the header information associated with
//                          the current frame. The frame header fields
//                          bitRate and id, bit rate index and algorithm
//                          identification, respectively, must contain valid
//                          data prior to calling the function
//                          BitReservoirInit_MP3 since both are used to
//                          generate the bit reservoir initialization
//                          parameters. All other frame header parameters
//                          are ignored by the bit reservoir initialization
//                          function. Only MPEG-1 (id = 1) is supported.
//    pDstBitResv           Pointer to the initialized IppMP3BitReservoir
//                          state structure. The structure element
//                          BitsRemaining is initialized as 0. The structure
//                          element MaxBits is initialized to reflect the
//                          maximum number of bits that can be contained in
//                          the reservoir at the start of any given frame.
//                          The appropriate value of MaxBits is directly
//                          determined by the selected algorithm (MPEG-1 or
//                          MPEG-2) and the stream bit rate indicated by the
//                          rate index parameter pFrameHeader.bitRate.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pDstBitResv or
//                          pFrameHeader is NULL.
//    ippStsMP3FrameHeaderErr Indicates an error when
//                          pFrameHeader->id != IPP_MP3_ID_MPEG1.
*/
IPPAPI(IppStatus, ippsBitReservoirInit_MP3, (
    IppMP3BitReservoir* pDstBitResv,
    IppMP3FrameHeader*  pFrameHeader))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTFwd_MP3_32s
//
//  Purpose:
//    Implements stage 2 of the MP3 hybrid analysis filterbank.
//
//  Parameters:
//    pSrc                  Pointer to the start of the 576-element block
//                          PQMF analysis output vector containing 18
//                          consecutive blocks of 32 subband samples that
//                          are indexed as follows:
//                          pDstS[32*i+sb], where i = 0,1,...,17 is time series
//                          index, sb = 0,1,...,31 is the subband index. All
//                          coefficients are represented using the Q7.24
//                          format.
//    pDst                  Pointer to the 576-element spectral coefficient
//                          output vector generated by the analysis
//                          filterbank.
//    blockType             Block type indicator: 0 stands for normal block;
//                          1 stands for start block; 2 stands for short
//                          block; 3 stands for stop block.
//    mixedBlock            Mixed block indicator: 0 stands for not mixed; 1
//                          stands for mixed.
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure that
//                          contains the header associated with the current
//                          frame. Only MPEG-1 (id = 1) is supported.
//    pOverlapBuf           Pointer to the MDCT overlap buffer that contains
//                          a copy of the most recent 576-element block of
//                          PQMF bank outputs. Prior to processing a new
//                          audio stream with the analysis filterbank, all
//                          elements of the buffer pOverlapBuf should be
//                          initialized to the constant value 0.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the pointers
//                          pSrcXs, pDstXr, pFrameHeader, or pOverlapBuf is
//                          NULL.
*/
IPPAPI(IppStatus, ippsMDCTFwd_MP3_32s, (
    const Ipp32s*       pSrc,
    Ipp32s*             pDst,
    int                 blockType,
    int                 mixedBlock,
    IppMP3FrameHeader*  pFrameHeader,
    Ipp32s*             pOverlapBuf))



/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsMDCTInvWindow_MP3_32s
//
//  Purpose:
//    Performs 36 or 18 points IMDCT and windowing depending on blockType.
//  Parameters:
//    pSrc                  pointer to the input buffer which is the
//                          output of alias reduction.
//
//    pDst                  pointer to the output buffer of IMDCT for
//                          long block (36 points) and short block (18 points).
//
//    blockType             Block type indicator: 0 stands for normal window,
//                                                1 stands for start block,
//                                                2 stands for short block,
//                                                3 stands for stop block.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when one of the pointers
//                          pSrc or pDst is NULL.
*/
IPPAPI(IppStatus, ippsMDCTInvWindow_MP3_32s,(
    Ipp32s* pSrc,
    Ipp32s* pDst,
    int     blockType))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisPQMF_MP3_16s32s
//
//  Purpose:
//    Implements stage 1 of MP3 hybrid analysis filterbank.
//
//  Parameters:
//    pSrcPcm               Pointer to the start of the buffer containing
//                          the input PCM audio vector. The samples conform
//                          to the following guidelines: - must be in 16-bit,
//                          signed, little-endian, Q15 format; - most
//                          recent 480 (512-32) samples should be contained
//                          in the vector pSrcPcm[pcmMode*i], where i = 0,1
//                          ,..,479; - samples associated with the current
//                          granule should be contained in the vector pSrcPcm
//                          [pcmMode*j], where j = 480,481,..,1055.
//    pcmMode               PCM mode flag. Communicates to PQMF filterbank
//                          the type of input PCM vector organization to
//                          expect: - pcmMode = 1 denotes non-interleaved
//                          PCM input samples; - pcmMode = 2 denotes
//                          interleaved PCM input samples.
//    pDstS                 Pointer to the start of the 576-element block
//                          PQMF analysis output vector containing 18
//                          consecutive blocks of 32 subband samples under
//                          the following index: pDstXs[32*i + sb], where i
//                          = 0,1,...,17 is time series index sb = 0,1,...,31 is
//                          the subband index.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSrcPcm or pDstXs is NULL.
//    ippStsErr             Indicates an error when pcmMode exceeds [1,2].
*/
IPPAPI(IppStatus, ippsAnalysisPQMF_MP3_16s32s, (
    const Ipp16s*       pSrcPcm,
    Ipp32s*             pDstS,
    int                 mode))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsJointStereoEncode_MP3_32s_I
//
//  Purpose:
//    Transforms independent left and right channel spectral coefficient
//    vectors into combined mid/side and/or intensity mode coefficient
//    vectors suitable for quantization.
//
//  Parameters:
//    pSrcDstXrL            Pointer to the 576-element joint stereo spectral
//                          coefficient output vector associated with the M
//                          channel, as well as the intensity coded
//                          coefficients above the intensity lower SFB bound.
//                          All elements are represented using the Q5.26
//                          format.
//    pSrcDstXrR            Pointer to the 576-element joint stereo spectral
//                          coefficient output vector associated with the S
//                          channel. All elements are represented using the
//                          Q5.26 format.
//    pDstScaleFactorR      Pointer to the vector of scalefactors associated
//                          with one granule of the right/S channel. If
//                          intensity coding has been enabled by the
//                          psychoacoustic model above a certain SFB lower
//                          bound, as indicated by the frame header and the
//                          vector pointed to by pIsSfbBound, the function
//                          StereoEncode_MP3_32s_I updates with the
//                          appropriate scalefactors those elements of
//                          pDstScaleFactorR[] that are associated with
//                          intensity coded scale factor bands. Other SFB
//                          entries in the scale factor vector remain
//                          unmodified. The length of the vector referenced
//                          by pDstScaleFactorR varies as a function of
//                          block size. The vector contains 21 elements for
//                          long block granules, or 36 elements for short
//                          block granules.
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure that
//                          contains the header information associated with
//                          the current frame. Upon function entry, the
//                          structure fields samplingFreq, id, mode, and
//                          modeExt should contain, respectively, the sample
//                          rate associated with the current input audio,
//                          the algorithm id (MPEG-1 or MPEG-2), and the
//                          joint stereo coding commands generated by the
//                          psychoacoustic model. All other pFrameHeader
//                          fields are ignored. Only MPEG-1 (id = 1) is
//                          supported.
//    pSideInfo             Pointer to the pair of IppMP3SideInfo structures
//                          associated with the channel pair to be jointly
//                          encoded. The number of elements in the set is 2,
//                          and ordering of the set elements is as follows:
//                          pSideInfo[0] describes channel 1, and pSideInfo[1
//                          ] describes channel 2. Upon the function entry,
//                          the blockType side information fields for both
//                          channels should reflect the analysis modes (
//                          short or long block) selected by the
//                          psychoacoustic model on each channel. All other
//                          fields in the pSideInfo[0] and pSideInfo[1]
//                          structures are ignored.
//    pIsSfbBound           Pointer to the list of intensity coding SFB
//                          lower bounds for both channels of the current
//                          granule above which all L/R channel spectral
//                          coefficients are combined into an intensity-
//                          coded representation. The number of elements
//                          depends on the block type associated with the
//                          current granule. For short blocks, the SFB
//                          bounds are represented in the following order:
//                          pIsSfbBound[0] describes block 1, pIsSfbBound[1]
//                          describes block 2, and pIsSfbBound[2] describes
//                          block 3. For long blocks, only a single SFB
//                          lower bound decision is required and is
//                          represented in pIsSfbBound[0]. If both MS and
//                          intensity coding are enabled, the SFB intensity
//                          coding lower bound simultaneously represents the
//                          upper bound SFB for MS coding. If only MS coding
//                          is enabled, the SFB bound represents the lowest
//                          non-MS SFB.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers pSrcDstXrL, pSrcDstXrR, pDstScaleFactorR,
//                          pFrameHeader, pSideInfo, or pIsSfbBound is NULL.
//    ippStsMP3SideInfoErr  Indicates an error if pSideInfo[0].blockType!=
//                          pSideInfo[1].blockType when IS or MS is used.
*/
IPPAPI(IppStatus, ippsJointStereoEncode_MP3_32s_I, (
    Ipp32s*             pSrcDstXrL,
    Ipp32s*             pSrcDstXrR,
    Ipp8s*              pDstScaleFactorR,
    IppMP3FrameHeader*  pFrameHeader,
    IppMP3SideInfo*     pSideInfo,
    int*                pIsSfbBound))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsQuantize_MP3_32s_I
//
//  Purpose:
//    Quantizes spectral coefficients generated by analysis filterbank.
//
//  Parameters:
//    pSrcDstXrIx           Pointer to the output set of quantized spectral
//                          coefficient vectors. These are suitable for
//                          input to the Huffman encoder. The coefficients
//                          are indexed as follows: pSrcDstXrIx[gr*1152 + ch*
//                          576 + i] for stereophonic and dual-mono input
//                          sources, and pSrcDstXrIx[gr*576 + i] for single
//                          channel input sources, where: - i=0,1,...,575 is
//                          the spectral coefficient index; - gr is the
//                          granule index. 0 stands for granule 1, 1 stands
//                          for granule 2; - ch is the channel index. 0
//                          stands for channel 1, 1 stands for channel 2.
//    pDstScaleFactor       Pointer to the output set of
//                          scalefactors generated during the quantization
//                          process. These scalefactors determine the
//                          quantizer granularity. Scale factor vector
//                          lengths depend on the block mode associated with
//                          each granule. The order of the elements is: 1. (
//                          granule 1, channel 1); 2. (granule 1, channel 2);
//                          3. (granule 2, channel 1); 4. (granule 2,
//                          channel 2). Given this general organization, the
//                          side information for each granule/channel in
//                          conjunction with the flags contained in the vector
//                          pDstScfsi can be used to determine the precise
//                          scale factor vector indices and lengths.
//    pDstScfsi             Pointer to the output vector of scale factor
//                          selection information. This vector contains a
//                          set of binary flags that indicate whether or not
//                          scalefactors are shared across granules of a
//                          frame within predefined scale factor selection
//                          groups. For example, bands 0,1,2,3,4,5 form one
//                          group; bands 6,7,8,9,10 form a second group, as
//                          defined in ISO/IEC 11172-3. The vector is
//                          indexed as follows: pDstScfsi[ch][scfsi_band],
//                          where: - ch is the channel index. 0 stands for
//                          channel 1, 1 stands for channel 2; - scfsi_band
//                          is the scale factor selection group number.
//                          Group 0 includes SFBs 0-5, group 1 includes SFBs
//                          6-10, group 2 includes SFBs 11-15, and group 3
//                          includes SFBs 16-20.
//    pDstCount1Len         Pointer to an output vector of count1 region
//                          length specifiers. For the purposes of Huffman
//                          coding spectral coefficients of a higher
//                          frequency than the bigvals region, the count1
//                          parameter indicates the size of the region in
//                          which spectral samples can be combined into
//                          quadruples for which all elements are of
//                          magnitude less than or equal to 1. The vector
//                          contains 2*nchan, elements and is indexed as
//                          follows: pDstCount1Len[gr*nchan + ch], where: -
//                          gr is the granule index. 0 stands for granule 1,
//                          1 stands for granule 2; - nchan is the number of
//                          channels; - ch is the channel index. 0 stands
//                          for channel 1, 1 stands for channel 2.
//    pDstHufSize           Pointer to an output vector of Huffman coding
//                          bit allocation specifiers. For each granule/
//                          channel, the specifiers indicate the total
//                          number of Huffman bits required to represent the
//                          quantized spectral coefficients in the bigvals
//                          and count1 regions. Whenever necessary, each
//                          HufSize bit count is augmented to include the
//                          number of bits required to manage the bit
//                          reservoir. For frames in which the reservoir has
//                          reached the maximum capacity, the quantizer
//                          expends the surplus bits by padding with
//                          additional bits the Huffman representation of
//                          the spectral samples. The HufSize result
//                          returned by the quantizer reflects these padding
//                          requirements. That is, HufSize[i] is equal to
//                          the sum of the number of bits required for
//                          Huffman symbols and the number of padding bits.
//                          The vector contains 2*nchan, elements and is
//                          indexed as follows: pDstHufSize[gr*nchan+ch],
//                          where: - gr is the granule index. 0 stands for
//                          granule 1, 1 stands for granule 2; - nchan is
//                          the number of channels; - ch is the channel index.
//                          0 stands for channel 1, 1 stands for channel 2.
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure that
//                          contains the header information associated with
//                          the current frame. Upon the function entry, the
//                          structure fields samplingFreq, id, mode, and
//                          modeExt should contain, respectively, the sample
//                          rate associated with the current input audio,
//                          the algorithm id, that is, MPEG-1 or MPEG-2, and
//                          the joint stereo coding commands generated by
//                          the psychoacoustic model. All other *
//                          pFrameHeader fields are ignored. Only MPEG-1 (id
//                          = 1) is supported.
//    pSideInfo             Pointer to the set of IppMP3SideInfo structures
//                          associated with all granules and channels. The
//                          set should contain 2*nchan, elements and should
//                          be indexed as follows: pSideInfo[gr*nchan + ch],
//                          where: - gr is the granule index. 0 stands for
//                          granule 1, 1 stands for granule 2; - nchan is
//                          the number of channels; - ch is the channel index.
//                          0 stands for channel 1, 1 stands for channel 2.
//                          Upon the function entry, in all set elements
//                          the structure fields blockType, mixedBlock, and
//                          winSwitch should contain, respectively, the
//                          block type indicator (start, short, or stop),
//                          filter bank mixed block analysis mode specifier,
//                          and window switching flags (normal
//                          or blockType) associated with the current
//                          input audio. All other *pSideInfo fields are
//                          ignored upon the function entry and updated upon
//                          function exit, as described below under the
//                          description of output arguments.
//    pPsychoInfo           Pointer to the first element in a set of
//                          PsychoacousticModelTwoAnalysis structures
//                          associated with the current frame. Each set
//                          member contains the MSR and PE estimates for one
//                          channel of one granule. The set should contain 2*
//                          nchan, elements and is indexed as: pPsychoaInfo[
//                          gr*nchan+ ch], where: - gr is the granule index.
//                          0 stands for granule 1, 1 stands for granule 2;
//                          - nchan is the number of channels; - ch is the
//                          channel index. 0 stands for channel 1, 1 stands
//                          for channel 2.
//    pFramePsyState        Pointer to the first element in a set of
//                          IppMP3PsychoacousticModelTwoState structures
//                          that contains the psychoacoustic model state
//                          information associated with both the current
//                          frame and next frame. The number of elements in
//                          the set is equal to the number of channels
//                          contained in the input audio. That is, a
//                          separate analysis is carried for each channel.
//                          The quantizer uses the frame type look ahead
//                          information nextBlockType to manage the bit
//                          reservoir. All other structure elements are
//                          ignored by the quantizer.
//    pResv                 Pointer to the updated IppMP3BitReservoir
//                          structure. The quantizer updates the
//                          BitsRemaining field to add or remove bits as
//                          necessary. All other fields are unmodified by
//                          the quantizer.
//    meanBits              The number of bits allocated on an average basis
//                          for each frame of spectral coefficients and
//                          scalefactors given the target bit rate (kilobits
//                          per second) specified in the frame header. This
//                          number excludes the bits allocated for the frame
//                          header and side information. The quantizer uses
//                          meanBits as a target allocation for the current
//                          frame. Given perceptual bit allocation
//                          requirements greater than this target, the
//                          quantizer makes use of the surplus bits held in
//                          the bit reservoir to satisfy frame-instantaneous
//                          demands. Similarly, given perceptual bit
//                          allocation requirements below this target, the
//                          quantizer will store surplus bits in the bit
//                          reservoir for use by future frames.
//    pIsSfbBound           Pointer to the list of SFB lower bounds above
//                          which all L/R channel spectral coefficients have
//                          been combined into an intensity-coded
//                          representation. The number of valid elements
//                          pointed to by pIsSfbBound
//                          depends upon the block types associated with the
//                          granules of the current frame. In particular,
//                          the list of SFB bounds pointed to by pIsSfbBound
//                          is indexed as follows: pIsSfbBound[3*gr] for
//                          long block granules, and pIsSfbBound[3*gr + w]
//                          for short block granules, where: - gr is the
//                          granule index. 0 stands for granule 1, 1 stands
//                          for granule 2; - w is the block index. 0 stands
//                          for block 1, 1 stands for block 2, 2 stands for
//                          block 3. For example, given short-block analysis
//                          in granule 1 followed by long block analysis in
//                          granule 2, the list of SFB bounds would be
//                          expected in the following order: pIsSfbBound[] =
//                          {granule 1/block 1, granule 1/block 2, granule 1/
//                          block 2, granule 2/long block}. If a granule is
//                          configured for long block analysis, then only a
//                          single SFB lower bound decision is expected,
//                          whereas three are expected for short block
//                          granules. If both MS and intensity coding have
//                          been enabled, then the SFB intensity coding
//                          lower bound simultaneously represents the upper
//                          bound SFB for MS coding. If only MS coding has
//                          been enabled, then the SFB bound represents the
//                          lowest non-MS SFB.
//    pWorkBuffer           Pointer to the workspace buffer internally used
//                          by the quantizer for storage of intermediate
//                          results and other temporary data. The buffer
//                          length should be at least 2880 bytes, that is,
//                          720 words of 32-bits each.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSrcDstXrIx,
//                          pDstScaleFactor, pDstScfsi, pDstCount1Len,
//                          pDstHufSize, pFrameHeader, pSideInfo, pPsychInfo,
//                          pFramePsyState, pResv, pIsSfbBound, or
//                          pWorkBuffer is NULL.
//    ippStsMP3SideInfo     Indicates an error when pSideInfo->winSwitch and
//                          pSideInfo->mixedBlock are both defined.
//    ippStsMP3FrameHeaderErr  Indicates an error when pFrameHeader->samplingFreq or
//                          pFrameHeader->id is not correct.
*/
IPPAPI(IppStatus, ippsQuantize_MP3_32s_I, (
    Ipp32s*             pSrcDstXrIx,
    Ipp8s*              pDstScaleFactor,
    int*                pDstScfsi,
    int*                pDstCount1Len,
    int*                pDstHufSize,
    IppMP3FrameHeader*  pFrameHeader,
    IppMP3SideInfo*     pSideInfo,
    IppMP3PsychoacousticModelTwoAnalysis*   pPsychInfo,
    IppMP3PsychoacousticModelTwoState*      pFramePsyState,
    IppMP3BitReservoir* pResv,
    int                 meanBits,
    int*                pIsSfbBound,
    Ipp32s*             pWorkBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsPsychoacousticModelTwo_MP3_16s
//
//  Purpose:
//    Implements ISO/IEC 11172-3 psychoacoustic model recommendation 2 to
//    estimate masked threshold and perceptual entropy associated with a
//    block of PCM audio input.
//
//  Parameters:
//    pSrcPcm               Pointer to the start of the buffer containing
//                          the input PCM audio vector, the samples of which
//                          should conform to the following format
//                          specification: - 16-bits per sample, signed,
//                          little-endian, Q15; - pSrcPcm buffer should
//                          contain 1152 samples, that is, two granules of
//                          576 samples each, if the parameter pFrameHeader
//                          -> mode has the value 1 (mono), or 2304 samples,
//                          that is, two granules of 576 samples each, if
//                          the parameter pFrameHeader -> mode has the value
//                          of 2 (stereo, dual mono); - In the stereophonic
//                          case, the PCM samples associated with the left
//                          and right channels should be organized according
//                          to the pcmMode flag. Failure to satisfy any of
//                          the above PCM format and/or buffer requirements
//                          results in undefined model outputs.
//    pDstPsyInfo           Pointer to the first element in a
//                          set of PsychoacousticModelTwoAnalysis structures.
//                          Each set member contains the MSR and PE
//                          estimates for one granule. The number of
//                          elements in the set is equal to the number of
//                          channels, with the outputs arranged as follows: (
//                          Analysis[0] = granule 1, channel 1), (...Analysis[1]
//                          = granule 1, channel 2), (...Analysis[2] =
//                          granule 2, channel 1), (...Analysis[3] = granule 2,
//                          channel 2).
//    pDstIsSfbBound        If intensity coding has been enabled,
//                          pDstIsSfbBound points to the list of SFB lower
//                          bounds above which all spectral coefficients
//                          should be processed by the joint stereo
//                          intensity coding module. Since the intensity
//                          coding SFB lower bound is block-specific, the
//                          number of valid elements pointed to by
//                          pDstIsSfbBound varies depending upon the
//                          individual block types associated with each
//                          granule. In particular, the list of SFB bounds
//                          is indexed as follows: - pIsSfbBound[3*gr] for
//                          long block granules; - pIsSfbBound[3*gr + w] for
//                          short block granules, where gr is the granule
//                          index (0 indicates granule 1 and 1 indicates
//                          granule 2), and w is the block index (0
//                          indicates block 1, 1 indicates block 2, 2
//                          indicates block 3). For example, given short-
//                          block analysis in granule 1 followed by long
//                          block analysis in granule 2, the list of SFB:
//                          bounds would be generated in the following order
//                          pIsSfbBound[] = {granule 1/block 1, granule 1/
//                          block 2, granule 1/block 2, granule 2/long
//                          block}. Only one SFB lower bound decision is
//                          generated for long block granules, whereas three
//                          are generated for short block granules. If both
//                          MS and intensity coding are enabled, then the
//                          SFB intensity coding lower bound simultaneously
//                          represents the upper bound SFB for MS coding. If
//                          only MS coding has been enabled, then the SFB
//                          bound represents the lowest non-MS SFB.
//    pDstSideInfo          Pointer to the updated set of IppMP3SideInfo
//                          structures associated with all granules and
//                          channels. The model updates the following fields
//                          in all set elements: blockType, winSwitch, and
//                          mixedBlock. The number of elements in the set is
//                          equal to 2 times the number of channels.
//                          Ordering of the set elements is the same as
//                          pDstPsyInfo.
//    pFrameHeader          Pointer to the IppMP3FrameHeader structure that
//                          contains the header associated with the current
//                          frame. The samplingFreq, id, and mode fields of
//                          the structure pFrameHeader control the behavior
//                          of the psychoacoustic model. All three fields
//                          must be appropriately initialized prior to
//                          calling this function. All other frame header
//                          fields are ignored. Only MPEG-1 (id = 1) is
//                          supported.
//    pFramePsyState        Pointer to the first element in a set of
//                          IppMP3PsychoacousticModelTwoState structures
//                          that contains the updated psychoacoustic model
//                          state information associated with both the
//                          current frame and next frame. The number of
//                          elements in the set is equal to the number of
//                          channels contained in the input audio. That is,
//                          a separate analysis is carried for each channel.
//                          Prior to encoding a new audio stream, all
//                          elements of the psychoacoustic model state
//                          structure pPsychoacousticModelState should be
//                          initialized to contain the value 0. In the
//                          signal processing domain, this could be
//                          accomplished using the function ippsZero_16s as
//                          follows: ippsZero_16s ((Ipp16s *)
//                          pPsychoacousticModelState,sizeof(
//                          IppMP3PsychoacousticModelTwoState)
//                          /sizeof(Ipp16s)).
//    pcmMode               PCM mode flag. Communicates the psychoacoustic
//                          model which type of PCM vector organization to
//                          expect: - pcmMode = 1 denotes non-interleaved
//                          PCM input samples, that is, pSrcPcm[0..1151]
//                          contains the input samples associated with the
//                          left channel, and pSrcPcm[1152..2303] contains
//                          the input samples associated with the right
//                          channel; - pcmMode = 2 denotes interleaved PCM
//                          input samples, that is, pSrcPcm[2*i] and pSrcPcm[
//                          2*i+1] contain the samples associated with the
//                          left and right channels, respectively, where i =
//                          0,1,...,1151. You can also use appropriately
//                          typecast elements ippMP3NonInterleavedPCM and
//                          ippMP3InterleavedPCM of the enumerated type
//                          IppMP3PcmMode as an alternative to the constants
//                          1 and 2 for pcmMode.
//    pWorkBuffer           Pointer to the workspace buffer internally used
//                          by the psychoacoustic model for storage of
//                          intermediate results and other temporary data.
//                          The buffer length must be at least 25,200 bytes,
//                          that is, 6300 elements of type Ipp32s.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when at least one of the
//                          pointers pSrcPcm, pDstPsyInfo, pDstSideInfo,
//                          pDstIsSfbBound, pFrameHeader, pDstPsyState, or
//                          pWorkBuffer is NULL.
*/
IPPAPI(IppStatus, ippsPsychoacousticModelTwo_MP3_16s, (
    const Ipp16s*       pSrcPcm,
    IppMP3PsychoacousticModelTwoAnalysis*   pDstPsyInfo,
    int*                pDstIsSfbBound,
    IppMP3SideInfo*     pDstSideInfo,
    IppMP3FrameHeader*  pFrameHeader,
    IppMP3PsychoacousticModelTwoState*      pFramePsyState,
    int                 pcmMode,
    Ipp32s*             pWorkBuffer))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilter_PQMF_MP3_32f
//
//  Purpose:
//    Transforms PQMF MP3-processed subband signals into time domain samples.
//
//  Parameters:
//    pSrc                  Array of pointers, holds PQMF MP3-processed subband
//                          signals.
//    pDst                  Pointer to the output vector, holds time domain
//                          output samples.
//    pFilterSpec           Pointer to the IppsFilterSpec_PQMF_MP3 specification
//                          structure.
//    mode                  Flag that indicates whether or not MP3 audio
//                          output channels should be interleaved.
//                            1 - indicates not interleaved,
//                            2 - indicates interleaved.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
//    ippStsBadArgErr       Indicates an error when mode exceeds [1, 2].
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI(IppStatus, ippsSynthesisFilter_PQMF_MP3_32f, (const  Ipp32f  *pSrc,
                                                            Ipp32f  *pDst,
                                                     const  IppsFilterSpec_PQMF_MP3 *pFilterSpec,
                                                            int     mode))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterGetSize_PQMF_MP3_32f
//
//  Purpose:
//    Returns size of IppsFilterSpec_PQMF_MP3 specification structure.
//
//  Parameters:
//    pSizeSpec             Address of the IppsFilterSpec_PQMF_MP3 specification
//                          structure size value in bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSizeSpec is NULL.
*/
IPPAPI(IppStatus, ippsSynthesisFilterGetSize_PQMF_MP3_32f, (int *pSizeSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterInit_PQMF_MP3_32f
//
//  Purpose:
//    Initializes synthesis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the IppsFilterSpec_PQMF_MP3
//                          specification structure is written. Only the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the IppsFilterSpec_PQMF_MP3
//                          specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
*/
IPPAPI(IppStatus, ippsSynthesisFilterInit_PQMF_MP3_32f, (IppsFilterSpec_PQMF_MP3 **ppFilterSpec,
                                                         Ipp8u                   *pMemSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterInitAlloc_PQMF_MP3_32f
//
//  Purpose:
//    Allocate memory for synthesis specification structure and initializes it.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the IppsFilterSpec_PQMF_MP3
//                          specification structure is written.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppFilterSpec is NULL.
*/
IPPAPI(IppStatus, ippsSynthesisFilterInitAlloc_PQMF_MP3_32f, (IppsFilterSpec_PQMF_MP3 **ppFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterFree_PQMF_MP3_32f
//
//  Purpose:
//    Frees memory allocated for internal IppsFilterSpec_PQMF_MP3 structure.
//
//  Parameters:
//    pFilterSpec           Pointer to the IppsFilterSpec_PQMF_MP3 specification
//                          structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pFilterSpec is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI(IppStatus, ippsSynthesisFilterFree_PQMF_MP3_32f, (IppsFilterSpec_PQMF_MP3 *pFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilter_PQMF_MP3_32f
//
//  Purpose:
//    Transforms time domain samples into PQMF MP3-processed subband signals .
//
//  Parameters:
//    pSrc                  Array of pointers, holds PQMF MP3-processed subband
//                          signals.
//    pDst                  Pointer to the output vector, holds time domain
//                          output samples.
//    pFilterSpec           Pointer to the IppsFilterSpec_PQMF_MP3 specification
//                          structure.
//    mode                  Flag that indicates whether or not MP3 audio
//                          output channels should be interleaved.
//                            1 - indicates not interleaved,
//                            2 - indicates interleaved.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
//    ippStsBadArgErr       Indicates an error when mode exceeds [1, 2].
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI(IppStatus, ippsAnalysisFilter_PQMF_MP3_32f, (const  Ipp32f  *pSrc,
                                                            Ipp32f  *pDst,
                                                     const  IppsFilterSpec_PQMF_MP3 *pFilterSpec,
                                                            int     mode))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterGetSize_PQMF_MP3_32f
//
//  Purpose:
//    Returns size of IppsFilterSpec_PQMF_MP3 specification structure.
//
//  Parameters:
//    pSizeSpec             Address of the IppsFilterSpec_PQMF_MP3 specification
//                          structure size value in bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSizeSpec is NULL.
*/
IPPAPI(IppStatus, ippsAnalysisFilterGetSize_PQMF_MP3_32f, (int *pSizeSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterInit_PQMF_MP3_32f
//
//  Purpose:
//    Initializes analysis specification structure.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the IppsFilterSpec_PQMF_MP3
//                          specification structure is written. Only the
//                          main function uses this structure.
//    pMemSpec              Pointer to the area for the IppsFilterSpec_PQMF_MP3
//                          specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
*/
IPPAPI(IppStatus, ippsAnalysisFilterInit_PQMF_MP3_32f, (IppsFilterSpec_PQMF_MP3 **ppFilterSpec,
                                                         Ipp8u                   *pMemSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterInitAlloc_PQMF_MP3_32f
//
//  Purpose:
//    Allocate memory for analysis specification structure and initializes it.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the IppsFilterSpec_PQMF_MP3
//                          specification structure is written.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppFilterSpec is NULL.
*/
IPPAPI(IppStatus, ippsAnalysisFilterInitAlloc_PQMF_MP3_32f, (IppsFilterSpec_PQMF_MP3 **ppFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsAnalysisFilterFree_PQMF_MP3_32f
//
//  Purpose:
//    Frees memory allocated for internal IppsFilterSpec_PQMF_MP3 structure.
//
//  Parameters:
//    pFilterSpec           Pointer to the IppsFilterSpec_PQMF_MP3 specification
//                          structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pFilterSpec is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI(IppStatus, ippsAnalysisFilterFree_PQMF_MP3_32f, (IppsFilterSpec_PQMF_MP3 *pFilterSpec))


/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilter_DTS_32f
//
//  Purpose:
//    Transforms QMF DTS processed subband signals into time domain samples.
//
//  Parameters:
//    pSrc                  Array of pointers, holds QMF DTS processed subband
//                          signals.
//    pDst                  Pointer to the output vector, holds time domain
//                          output samples.
//    pFilterSpec           Pointer to the IppsFilterSpec_DTS_32f specification
//                          structure.
//    filtType              Flag, indicates filter bank.
//                            IPPAC_DTS_PERFECT - perfect reconstruction
//                            IPPAC_DTS_NONPERFECT - nonperfect reconstruction.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
//    ippStsBadArgErr       Indicates an error when filtType is neither
//                          IPPAC_DTS_PERFECT nor IPPAC_DTS_NONPERFECT.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI(IppStatus, ippsSynthesisFilter_DTS_32f, (const  Ipp32f  *pSrc,
                                                Ipp32f  *pDst,
                                                Ipp32s filt_type,
                                                const  IppsFilterSpec_DTS_32f *pFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterGetSize_DTS_32f
//
//  Purpose:
//    Returns size of IppsFilterSpec_DTS_32f specification structure.
//
//  Parameters:
//    pSizeSpec             Address of the IppsFilterSpec_DTS_32f specification
//                          structure size value in bytes.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pSizeSpec is NULL.
*/
IPPAPI(IppStatus, ippsSynthesisFilterGetSize_DTS_32f, (int *pSizeSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterInit_DTS_32f
//
//  Purpose:
//    Initializes DTS synthesis specification structure.
//
//  Parameters:
//    pFilterSpec          Pointer to the IppsFilterSpec_DTS_32f
//                         specification structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when any of the specified
//                          pointers is NULL.
*/
IPPAPI(IppStatus, ippsSynthesisFilterInit_DTS_32f, (IppsFilterSpec_DTS_32f *pFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterInitAlloc_DTS_32f
//
//  Purpose:
//    Allocate memory for synthesis specification structure and initializes it.
//
//  Parameters:
//    ppFilterSpec          Pointer to where pointer to the IppsFilterSpec_DTS_32f
//                          specification structure is written.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when ppFilterSpec is NULL.
*/
IPPAPI(IppStatus, ippsSynthesisFilterInitAlloc_DTS_32f, (IppsFilterSpec_DTS_32f **ppFilterSpec))

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippsSynthesisFilterFree_DTS_32f
//
//  Purpose:
//    Frees memory allocated for internal IppsFilterSpec_DTS_32f structure.
//
//  Parameters:
//    pFilterSpec           Pointer to the IppsFilterSpec_DTS_32f specification
//                          structure.
//
//  Returns:
//    ippStsNoErr           Indicates no error.
//    ippStsNullPtrErr      Indicates an error when pFilterSpec is NULL.
//    ippStsContextMatchErr Indicates an error when the identifier
//                          pFilterSpec is incorrect.
*/
IPPAPI(IppStatus, ippsSynthesisFilterFree_DTS_32f, (IppsFilterSpec_DTS_32f *pFilterSpec))

#ifdef __cplusplus
}
#endif

#if defined (_IPP_STDCALL_CDECL)
  #undef  _IPP_STDCALL_CDECL
  #define __stdcall __cdecl
#endif

#endif  /* #if !defined(__IPPAC_H__ ) || defined(_OWN_BLDPCS ) */