winamp/Src/external_dependencies/intel_ipp_6.1.1.035/em64t/include/ippsr.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
//                  Speech Recognition Reference Library
//
*/

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

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

#ifndef __IPPDEFS_H__
  #include "ippdefs.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if !defined( _OWN_BLDPCS )

/* /////////////////////////////////////////////////////////////////////////////
//       Common Types & Definitions
///////////////////////////////////////////////////////////////////////////// */
typedef enum {
    IPP_DELTA_BEGIN=0x0001,
    IPP_DELTA_END=0x0002
} DeltaMode;

#define   ippsDeltaBegin   IPP_DELTA_BEGIN
#define   ippsDeltaEnd     IPP_DELTA_END

typedef enum {
   IPP_FBANK_MELWGT = 1,
   IPP_FBANK_FREQWGT = 2,
   IPP_POWER_SPECTRUM = 4
} IppMelMode;

typedef enum {
   IPP_VOICE = 1,
   IPP_UNVOICE = 2,
   IPP_PREPARE = 4
} IppVADDecision_Aurora;

typedef enum {
    IPP_CDBK_FULL = 1,
    IPP_CDBK_KMEANS_LONG = 2,
    IPP_CDBK_KMEANS_NUM = 3
} Ipp_Cdbk_Hint;

struct BlockDMatrix_32f;
struct BlockDMatrix_64f;
struct BlockDMatrix_16s;

typedef struct BlockDMatrix_32f IppsBlockDMatrix_32f;
typedef struct BlockDMatrix_64f IppsBlockDMatrix_64f;
typedef struct BlockDMatrix_16s IppsBlockDMatrix_16s;

struct FBankState_16s;
struct DCTLifterState_16s;
struct FBankState_32f;
struct DCTLifterState_32f;
struct VADDrop_32f;
struct VADDrop_16s;
struct ResamplingPolyphase_16s;
struct ResamplingPolyphaseFixed_16s;
struct ResamplingPolyphase_32f;
struct ResamplingPolyphaseFixed_32f;
struct FBankState_32s;

typedef struct ResamplingPolyphase_16s IppsResamplingPolyphase_16s;
typedef struct ResamplingPolyphaseFixed_16s IppsResamplingPolyphaseFixed_16s;
typedef struct ResamplingPolyphase_32f IppsResamplingPolyphase_32f;
typedef struct ResamplingPolyphaseFixed_32f IppsResamplingPolyphaseFixed_32f;

#define IppsResamlingPolyphase_16s IppsResamplingPolyphase_16s
#define IppsResamlingPolyphaseFixed_16s IppsResamplingPolyphaseFixed_16s
#define IppsResamlingPolyphase_32f IppsResamplingPolyphase_32f
#define IppsResamlingPolyphaseFixed_32f IppsResamplingPolyphaseFixed_32f

typedef struct VADDrop_32f IppsVADDrop_32f;
typedef struct VADDrop_16s IppsVADDrop_16s;
typedef struct FBankState_16s IppsFBankState_16s;
typedef struct DCTLifterState_16s IppsDCTLifterState_16s;
typedef struct FBankState_32f IppsFBankState_32f;
typedef struct DCTLifterState_32f IppsDCTLifterState_32f;
typedef struct FBankState_32s IppsFBankState_32s;

struct CdbkState_32f;
typedef struct CdbkState_32f IppsCdbkState_32f;

struct CdbkState_16s;
typedef struct CdbkState_16s IppsCdbkState_16s;

#endif /* _OWN_BLDPCS */

#define IPP_TRUNC(a,b) ((a)&~((b)-1))
#define IPP_APPEND(a,b) (((a)+(b)-1)&~((b)-1))

/* /////////////////////////////////////////////////////////////////////////////
//                  Definitions for LogAdd Functions
///////////////////////////////////////////////////////////////////////////// */
/*Ipp64f*/
#define IPPSLOGZERO         (-1.0e+10)
#define IPPSLOGSMALL        (-0.9e+10)
#define IPPSMINLOGEXP  -23.0258509299405  /*-log(-LOGZERO)*/
#define IPPSMAXFWDP         (-1.0e-8)     /* highest p<0: exp(p) < DBL_EPSILON */
#define IPPSMINFWDP         -20.0         /* minimum forward probability */
/*Ipp32f*/
#define IPPSLOGZERO_F       (-4.5e+6)
#define IPPSLOGSMALL_F      (-4.5e+6)
#define IPPSMINLOGEXP_F -15.3195879547406 /*-log(-LOGZERO) */
#define IPPSMAXFWDP_F        (-1.0e-4)    /* highest p<0: exp(p) < FLT_EPSILON */
#define IPPSMINFWDP_F       -10.0         /* minimum forward probability */

/* /////////////////////////////////////////////////////////////////////////////
//                  Definitions for LogSub Functions
///////////////////////////////////////////////////////////////////////////// */
#define IPPSMINLARG         (2.45E-308)  /* lowest log() arg  = exp(MINEARG) */
#define IPPSMINMIX          (-11.5129254649702) /* log(1.0e-5) */
#define IPPSMINEARG         (-708.3)     /* lowest exp() arg  = log(MINLARG) */
#define IPPSMINEARG_F         (-85.19)     /* lowest exp() arg  = log(MINLARG_F) */
#define IPPSMINLARG_F       (1.0057e-037)  /* lowest log() arg  = exp(MINEARG_F) */


/* /////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//                   Functions declarations
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// */


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsrGetLibVersion
//  Purpose:    getting of the library version
//  Returns:    the structure of information about  version of ippsr library
//  Parameters:
//
//  Notes:      not necessary to release the returned structure
*/
IPPAPI( const IppLibraryVersion*, ippsrGetLibVersion, (void) )
/* /////////////////////////////////////////////////////////////////////////////
//  Basic Arithmetics
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsAddAllRowSum_32f_D2
//  Purpose:           Calculates the sums of column vectors in a matrix
//                     and adds the sums to a vector.
//  Parameters:
//    pSrc             Pointer to the input vector [height*sStep].
//    mSrc             Pointer to the input matrix [height][width].
//    step             The row step in pSrc.
//    height           The number of rows in the input matrix mSrc.
//    width            Number of columns in the input matrix mSrc, and also the
//                     length of the output vector pSrcDst.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, or mSrc, or pSrcDst
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than
//                     or equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsAddAllRowSum_32f_D2, (const Ipp32f* pSrc, int step,
       int height, Ipp32f* pSrcDst, int width))

IPPAPI(IppStatus, ippsAddAllRowSum_32f_D2L, (const Ipp32f** mSrc, int height,
       Ipp32f* pSrcDst, int width))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSumColumn_*
//  Purpose:           Calculates sums of column vectors in a matrix.
//
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    step             The row step in the input vector pSrc.
//    height           The number of rows in the input matrix mSrc.
//    pDst             Pointer to the output vector [width].
//    width            The number of columns in the input matrix and the length
//                        of the result vector pDst.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, mSrc, or pDst pointer
//                     is null.
//    ippStsSizeErr    Indicates an error when height or width is less than
//                     or equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsSumColumn_16s32s_D2Sfs,(const Ipp16s* pSrc, int step,
       int height, Ipp32s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus, ippsSumColumn_16s32f_D2,(const Ipp16s* pSrc, int step,
       int height, Ipp32f* pDst, int width))

IPPAPI(IppStatus, ippsSumColumn_16s32s_D2LSfs,(const Ipp16s** mSrc, int height,
       Ipp32s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus, ippsSumColumn_16s32f_D2L,(const Ipp16s** mSrc, int height,
       Ipp32f* pDst, int width))

IPPAPI(IppStatus, ippsSumColumn_32f_D2,(const Ipp32f* pSrc, int step,
       int height, Ipp32f* pDst, int width))

IPPAPI(IppStatus, ippsSumColumn_64f_D2,(const Ipp64f* pSrc, int step,
       int height, Ipp64f* pDst, int width))

IPPAPI(IppStatus, ippsSumColumn_32f_D2L,(const Ipp32f** mSrc, int height,
       Ipp32f* pDst, int width))

IPPAPI(IppStatus, ippsSumColumn_64f_D2L,(const Ipp64f** mSrc, int height,
       Ipp64f* pDst, int width))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSumRow_*
//  Purpose:           Computes the sum of a list of vectors row-wise.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    height           The number of rows in the matrix mSrc and also the length
//                     of the output vector pDst.
//    step             The row step in input vector pSrc.
//    pDst             Pointer to the output vector [height].
//    width            The number of columns in the matrix mSrc.
//    scaleFactor
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pSrc, mSrc, or pDst pointer
//                     is null.
//    ippStsSizeErr    Indicates an error when height or srcWidth is less than
//                     or equal to 0.
//    ippStsStrideErr  Indicates an error when srcWidth > step.
//
*/
IPPAPI(IppStatus, ippsSumRow_32f_D2,(const Ipp32f* pSrc, int width,
       int step, Ipp32f* pDst, int height))

IPPAPI(IppStatus, ippsSumRow_64f_D2,(const Ipp64f* pSrc, int width,
       int step, Ipp64f* pDst, int height))

IPPAPI(IppStatus, ippsSumRow_32f_D2L,(const Ipp32f** mSrc, int width,
       Ipp32f* pDst, int height))

IPPAPI(IppStatus, ippsSumRow_64f_D2L,(const Ipp64f** mSrc, int width,
       Ipp64f* pDst, int height))

IPPAPI(IppStatus, ippsSumRow_16s32s_D2Sfs,(const Ipp16s* pSrc, int width,
       int step, Ipp32s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsSumRow_16s32f_D2,(const Ipp16s* pSrc, int width,
       int step, Ipp32f* pDst, int height))

IPPAPI(IppStatus, ippsSumRow_16s32s_D2LSfs,(const Ipp16s** mSrc, int width,
       Ipp32s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsSumRow_16s32f_D2L,(const Ipp16s** mSrc, int width,
       Ipp32f* pDst, int height))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSubRow_*
//  Purpose:           Subtracts a vector from all matrix rows.
//  Parameters:
//    pSrc             Pointer to the input vector [width].
//    pSrcDst          Pointer to the the source and destination vector
//                     [height*dstStep].
//    mSrcDst          Pointer to the source and destination matrix
//                     [height][width].
//    width            The number of columns in the matrix mSrcDst.
//    dstStep          The row step in the vector pSrcDst.
//    height           The number of rows in the matrix mSrcDst.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pSrcDst, or mSrcDst
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > dstStep.
//
*/
IPPAPI(IppStatus, ippsSubRow_32f_D2, (const Ipp32f* pSrc, int width,
       Ipp32f* pSrcDst, int dstStep, int height))

IPPAPI(IppStatus, ippsSubRow_32f_D2L, (const Ipp32f* pSrc, Ipp32f** mSrcDst,
       int width, int height))

IPPAPI(IppStatus, ippsSubRow_16s_D2,(const Ipp16s* pSrc, int width,
       Ipp16s* pSrcDst, int dstStep, int height))

IPPAPI(IppStatus, ippsSubRow_16s_D2L,(const Ipp16s* pSrc, Ipp16s** mSrcDst,
       int width, int height))

/*///////////////////////////////////////////////////////////////////////////////
//  Name:              ippsCopyColumn_Indirect_*
//  Purpose:           Copies the input matrix with columns redirection.
//  Parameters:
//    pSrc             Pointer to the input vector [height*srcStep].
//    mSrc             Pointer to the input matrix [height][srcLen].
//    srcLen           The number of columns in the input matrix mSrc.
//    srcStep          The row step in pSrc
//    pDst             Pointer to the output vector [height*dstStep]
//    mDst             Pointer to the output matrix [height][dstLen]
//    pIndx            Pointer to the redirection vector [dstLen]
//    dstLen           The number of columns in the output matrix mDst
//    dstStep          The row step in pDst
//    height           The number of rows in both the input and output matrices.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, mSrc, pDst, mDst or
//                     pIndx pointer is null.
//    ippStsSizeErr    Indicates an error when height, srcLen, or dstLen is less
//                     than or equal to 0,
//                     pIndx[j]>=srcLen or pIndx[j]<0 for j=0,:,dstlen-1
//    ippStsStrideErr  Indicates an error when srcLen > srcStep, dstLen > dstStep.
//
*/
IPPAPI(IppStatus, ippsCopyColumn_Indirect_64f_D2, (const Ipp64f* pSrc,
       int srcLen, int srcStep, Ipp64f* pDst, const Ipp32s* pIndx, int dstLen,
       int dstStep, int height))

IPPAPI(IppStatus, ippsCopyColumn_Indirect_32f_D2, (const Ipp32f* pSrc,
       int srcLen, int srcStep, Ipp32f* pDst, const Ipp32s* pIndx, int dstLen,
       int dstStep, int height))

IPPAPI(IppStatus, ippsCopyColumn_Indirect_16s_D2, (const Ipp16s* pSrc,
       int srcLen, int srcStep, Ipp16s* pDst, const Ipp32s* pIndx, int dstLen,
       int dstStep, int height))

IPPAPI(IppStatus, ippsCopyColumn_Indirect_64f_D2L, (const Ipp64f** mSrc,
       int srcLen, Ipp64f** mDst, const Ipp32s* pIndx, int dstLen, int height))

IPPAPI(IppStatus, ippsCopyColumn_Indirect_32f_D2L, (const Ipp32f** mSrc,
       int srcLen, Ipp32f** mDst, const Ipp32s* pIndx, int dstLen, int height))

IPPAPI(IppStatus, ippsCopyColumn_Indirect_16s_D2L, (const Ipp16s** mSrc,
       int srcLen, Ipp16s** mDst, const Ipp32s* pIndx, int dstLen, int height))


/*///////////////////////////////////////////////////////////////////////////////
//  Name:              ippsBlockDMatrixInitAlloc_*
//  Purpose:           Initializes the structure that represents a symmetric
//                     block diagonal matrix.
//  Parameters:
//    pMatrix          Pointer to the block diagonal matrix to be created.
//    mSrc             Pointer to the vector of pointers to matrix rows.
//    bSize               Pointer to vector of block sizes [nBlocks].
//    nBlocks          Number of blocks.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pMatrix or mSrc pointer is null.
//    ippStsSizeErr    Indicates an error when bSize or nBlocks is less than or
//                     equal to 0
//    ippStsMemAllocErr Indicates an error when no memory allocated.
//
*/
IPPAPI(IppStatus, ippsBlockDMatrixInitAlloc_64f,(IppsBlockDMatrix_64f** pMatrix,
       const Ipp64f** mSrc, const int* bSize, int nBlocks))

IPPAPI(IppStatus, ippsBlockDMatrixInitAlloc_16s,(IppsBlockDMatrix_16s** pMatrix,
       const Ipp16s** mSrc, const int* bSize, int nBlocks))

IPPAPI(IppStatus, ippsBlockDMatrixInitAlloc_32f,(IppsBlockDMatrix_32f** pMatrix,
       const Ipp32f** mSrc, const int* bSize, int nBlocks))

/*///////////////////////////////////////////////////////////////////////////////
//  Name:              ippsBlockDMatrixFree_*
//  Purpose:           Deallocates the block diagonal matrix structure.
//
//  Parameters:
//    pMatrix          Pointer to the block diagonal matrix.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrc.
//
*/
IPPAPI(IppStatus, ippsBlockDMatrixFree_32f,(IppsBlockDMatrix_32f* pMatrix))

IPPAPI(IppStatus, ippsBlockDMatrixFree_64f,(IppsBlockDMatrix_64f* pMatrix))

IPPAPI(IppStatus, ippsBlockDMatrixFree_16s,(IppsBlockDMatrix_16s* pMatrix))


/* /////////////////////////////////////////////////////////////////////////////
//  Feature Processing functions
///////////////////////////////////////////////////////////////////////////// */

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsZeroMean_16s
//  Purpose:           Subtracts the mean value from all elements of
//                     the input vector.
//
//  Parameters:
//    pSrcDst          Pointer to the source and destination vector [len].
//    len              The number of elements in the vector.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcDst pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0.
//
*/

IPPAPI(IppStatus, ippsZeroMean_16s, (Ipp16s *pSrcDst, int len))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsCompensateOffset_*
//  Purpose:           Removes the DC offset of the input signals.
//
//  Parameters:
//    pSrc             Pointer to the source vector[len].
//    pDst             Pointer to the destination vector[len].
//    pSrcDst          Pointer to the source and destination vector for in-place
//                     operations [len].
//    pSrcDst0         Pointer to the previous source element.
//    pSrc0            Pointer to previous source element. The last source
//                     element is saved there.
//    dst0             Previous destination element.
//    val              Constant of offset compensation formula.
//    len              The number of elements in the vector.
//    scaleFactor
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pSrcDst or pDst or
//                     pSrc0 pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0
//
*/

IPPAPI(IppStatus, ippsCompensateOffset_32f, (const Ipp32f* pSrc, Ipp32f* pDst,
       int len, Ipp32f* pSrc0, Ipp32f dst0, Ipp32f val))

IPPAPI(IppStatus, ippsCompensateOffset_16s, (const Ipp16s* pSrc, Ipp16s* pDst,
       int len, Ipp16s* pSrcDst0, Ipp16s dst0, Ipp32f val))

IPPAPI(IppStatus, ippsCompensateOffset_32f_I, (Ipp32f* pSrcDst, int len,
       Ipp32f* pSrc0, Ipp32f dst0, Ipp32f val))

IPPAPI(IppStatus, ippsCompensateOffset_16s_I, (Ipp16s* pSrcDst, int len,
       Ipp16s* pSrcDst0, Ipp16s dst0, Ipp32f val))

IPPAPI(IppStatus, ippsCompensateOffsetQ15_16s, (const Ipp16s* pSrc, Ipp16s* pDst,
       int len, Ipp16s* pSrcDst0, Ipp16s dst0, Ipp16s valQ15))

IPPAPI(IppStatus, ippsCompensateOffsetQ15_16s_I, (Ipp16s* pSrcDst, int len,
       Ipp16s* pSrc0, Ipp16s dst0, Ipp16s valQ15))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSignChangeRate_*
//  Purpose:           Counts the zero-cross rate for the input signal.
//
//  Parameters:
//    pSrc             Pointer to the input signal [len].
//    len              Number of elements in the input signal.
//    pRes             Pointer to the result variable.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pRes pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsSignChangeRate_16s,(const Ipp16s* pSrc, int len,
       Ipp32s* pRes))

IPPAPI(IppStatus, ippsSignChangeRate_32f,(const Ipp32f* pSrc, int len,
       Ipp32f* pRes))

IPPAPI(IppStatus, ippsSignChangeRateXor_32f,(const Ipp32f* pSrc, int len,
       Ipp32s* pRes))

IPPAPI(IppStatus, ippsSignChangeRate_Count0_16s,(const Ipp16s* pSrc, int len,
       Ipp32s* pRes))

IPPAPI(IppStatus, ippsSignChangeRate_Count0_32f,(const Ipp32f* pSrc, int len,
       Ipp32f* pRes))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLinearPrediction_*
//  Purpose:           Performs linear prediction analysis on the input vector.
//
//  Parameters:
//    pSrc             Pointer to the input vector [lenSrc]
//    lenSrc           Length of the input vector pSrc.
//    pDst             Pointer to the output LPC coefficients vector [lenDst].
//    lenDst           Length of the output vector pDst.
//    scaleFactor
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or  pDst pointer is null.
//    ippStsSizeErr    Indicates an error when lenSrc or  lenDst is less than or
//                     equal to 0, lenDst is greater or equal than lenSrc.
//    ippStsNoOperation Indicates no solution to the LPC problem.
//
*/
IPPAPI(IppStatus, ippsLinearPrediction_Cov_32f,(const Ipp32f *pSrc, int lenSrc,
       Ipp32f *pDst, int lenDst))

IPPAPI(IppStatus, ippsLinearPrediction_Cov_16s_Sfs,(const Ipp16s* pSrc, int lenSrc,
       Ipp16s* pDst, int lenDst, int scaleFactor))

IPPAPI(IppStatus, ippsLinearPrediction_Auto_32f,(const Ipp32f *pSrc, int lenSrc,
       Ipp32f *pDst, int lenDst))

IPPAPI(IppStatus, ippsLinearPrediction_Auto_16s_Sfs,(const Ipp16s* pSrc, int lenSrc,
       Ipp16s* pDst, int lenDst, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLinearPredictionNeg_Auto_*
//  Purpose:           Performs linear prediction analysis on the input vector.
//            The same formula as ippsLinearPrediction_Auto with -r[k] in the right part
//
//  Parameters:
//    pSrc             Pointer to the input vector [lenSrc]
//    lenSrc           Length of the input vector pSrc.
//    pDst             Pointer to the output LPC coefficients vector [lenDst].
//    lenDst           Length of the output vector pDst.
//    scaleFactor
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or  pDst pointer is null.
//    ippStsSizeErr    Indicates an error when lenSrc or  lenDst is less than or
//                     equal to 0, lenDst is greater or equal than lenSrc.
//    ippStsNoOperation Indicates no solution to the LPC problem.
//
*/
IPPAPI(IppStatus, ippsLinearPredictionNeg_Auto_32f,(const float *pSrc,int lenSrc,float *pDst,
                                                    int lenDst))
IPPAPI(IppStatus, ippsLinearPredictionNeg_Auto_16s_Sfs, (const Ipp16s* pSrc, int lenSrc,
       Ipp16s* pDst, int lenDst, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDurbin_*
//  Purpose:           Performs Durbin's recursion on an input vector
//                     of autocorrelations.
//  Parameters:
//    pSrc             Pointer to the input vector [ len+1].
//    pDst             Pointer to the output LPC coefficients vector [len].
//    len              Length of the input and output vectors.
//    pErr             Pointer to the residual prediction error.
//    scaleFactor
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or  pDst or pErr
//                     pointer is null.
//   ippStsSizeErr     Indicates an error when lenis less than or equal to 0
//   ippStsMemAllocErr memory alllocation error
//   ippStsNoOperation ndicates no solution to the LPC problem.
//
*/
IPPAPI(IppStatus, ippsDurbin_32f,(const Ipp32f *pSrc, Ipp32f *pDst, int lenDst,
       Ipp32f* pErr))

IPPAPI(IppStatus, ippsDurbin_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
       int lenDst,Ipp32f* pErr, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLPToCepstrum_*
//  Purpose:           Calculates cepstrum coefficients from linear
//                     prediction coefficients.
//  Parameters:
//    pSrc             Pointer to the linear prediction coefficients [len].
//    pDst             Pointer to the cepstrum coefficients [len].
//    len              Number of elements in the source and destination vectors.
//    scaleFactor
//  Return:
//    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, ippsLPToCepstrum_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
       int len))

IPPAPI(IppStatus, ippsLPToCepstrum_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
       int len, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsCepstrumToLP_*
//  Purpose:           Calculates linear prediction coefficients from
//                     cepstrum coefficients.
//  Parameters:
//    pSrc             Pointer to the cepstrum coefficients [len].
//    pDst             Pointer to the linear prediction coefficients [len].
//    len              Number of elements in the source and destination vectors.
//    scaleFactor
//  Return:
//    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, ippsCepstrumToLP_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
       int len))

IPPAPI(IppStatus, ippsCepstrumToLP_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
       int len, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLPToReflection_*
//  Purpose:           Calculates the linear prediction reflection
//                     coefficients from the linear prediction coefficients.
//  Parameters:
//    pSrc             Pointer to the linear prediction coefficients [len].
//    pDst             Pointer to the linear prediction reflection coefficients [len].
//    len              Number of elements in the source and destination vectors.
//    scaleFactor
//  Return:
//    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.
//    ippStsNoOperation Indicates that reflection coefficients could not be calculated
//
*/
IPPAPI(IppStatus, ippsLPToReflection_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
       int len))

IPPAPI(IppStatus, ippsLPToReflection_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
       int len, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////

//  Name:        ippsDTW_L2_32f_D2L*
//  Purpose:     Computes the distance between observation and reference vector
//               sequences using Dynamic Time Warping algorithm.
//
//  Parameters:
//    pSrc1        Pointer to the first input (observation) vector   [height1*step].
//    pSrc2        Pointer to the second input (reference) vector   [height2*step].
//    mSrc1        Pointer to the first input (observation) matrix   [height1][width].
//    mSrc2        Pointer to the second input (reference) matrix   [height2][width].
//    height1      Number of rows in the first input matrix N1.
//    height2      Number of rows in the first input matrix N2.
//    width        Length of the input matrices row M.
//    step         Row step in pSrc1 and pSrc2.
//    pDist        Pointer to the distance value.
//    beam         Beam value, used if positive.
//    delta        Endpoint constraint value.
//    scaleFactor  Scale factor for input values .
//  Return Value
//    ippStsNoErr        Indicates no error.
//    ippStsNullPtrErr   Indicates an error when the pSrc1, pSrc2, mSrc1, mSrc2, or pDist pointer is null.
//    ippStsSizeErr      Indicates an error when height1, height2, or width is less than or equal to 0 or delta is less than 0 or greater than height2.
//    ippStsStrideErr    Indicates an error when step is less than width.
//    ippStsLPCCalcErr   Indicates that there are now admissible paths for height1, height2 and delta values.
*/
IPPAPI(IppStatus, ippsDTW_L2_32f_D2L,(const Ipp32f** mSrc1, int height1,
                                      const Ipp32f** mSrc2, int height2,
                                      int width, Ipp32f* pDist, int delta,
                                      Ipp32f beam))
IPPAPI(IppStatus, ippsDTW_L2_32f_D2,(const Ipp32f* mSrc1, int height1,
                                      const Ipp32f* mSrc2, int height2,
                                      int width, int step, Ipp32f* pDist, int delta,
                                      Ipp32f beam))
IPPAPI(IppStatus, ippsDTW_L2_8u32s_D2Sfs,(const Ipp8u* pSrc1, int height1,
                                          const Ipp8u* pSrc2, int height2,
                                          int width, int step, Ipp32s* pDist, int delta,
                                          Ipp32s beam, int scaleFactor))
IPPAPI(IppStatus, ippsDTW_L2_8u32s_D2LSfs,(const Ipp8u** mSrc1, int height1,
                                           const Ipp8u** mSrc2, int height2,
                                           int width, Ipp32s* pDist, int delta,
                                           Ipp32s beam, int scaleFactor))
IPPAPI(IppStatus, ippsDTW_L2Low_16s32s_D2Sfs,(const Ipp16s* pSrc1, int height1,
                                              const Ipp16s* pSrc2, int height2,
                                              int width, int step, Ipp32s* pDist, int delta,
                                              Ipp32s beam, int scaleFactor))
IPPAPI(IppStatus, ippsDTW_L2Low_16s32s_D2LSfs,(const Ipp16s** mSrc1, int height1,
                                               const Ipp16s** mSrc2, int height2,
                                               int width, Ipp32s* pDist, int delta,
                                               Ipp32s beam, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSchur_*
//  Purpose:           Schur's recursion for an input vector of
//                     autocorrelations.
//
//  Parameters:
//    pSrc        Pointer to the input autocorrelations vector [len+1].
//    pDst        Pointer to the output reflection coefficients vector [len].
//    len         Length of the output vectors.
//    pErr        Pointer to the resulting prediction error.
//    scaleFactor
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pDst or pErr pointer
//                     is null.
//    ippStsSizeErr    Indicates an error when lenSrc or  lenDst is less than or
//                     equal to 0 or pSrc <  pDst.
//    ippStsMemAllocErr memory alllocation error
//    ippStsDivByZeroErr Indicates no solution to the LPC problem
*/
IPPAPI(IppStatus, ippsSchur_32f,(const Ipp32f* pSrc, Ipp32f* pDst, int len, Ipp32f* pErr))
IPPAPI(IppStatus, ippsSchur_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst, int len,
                                            Ipp32f* pErr,int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsReflectionToLP_*
//  Purpose:           Calculates the linear prediction coefficients from
//                     the linear prediction reflection coefficients.
//  Parameters:
//    pSrc             Pointer to the linear prediction reflection coefficients [len].
//    pDst             Pointer to the linear prediction coefficients [len].
//    len              Number of elements in the source and destination vectors.
//    scaleFactor
//  Return:
//    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, ippsReflectionToLP_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
       int len))
IPPAPI(IppStatus, ippsReflectionToLP_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
       int len, int scaleFactor))

/*/////////////////////////////////////////////////////////////////////////////
//  Name:         ippsReflectionToAR_*
//                ippsReflectionToLAR_*
//                ippsReflectionToTrueAR_*
//  Purpose:      Converts reflection coefficients to area ratios.
//
//  Parameters:
//    pSrc           Pointer to the input vector [len].
//    pDst           Pointer to the destination vector [len].
//    val            Threshold value ( 0 < val < 1 ).
//    len            Length of the input and output vectors.
//
//  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.
//    ippStsDivByZero   Indicates a warning for zero-valued divisor vector
//                      element. Operation execution is not aborted. The value of
//                      the destination vector element in the floating-point
//                      operations +Inf. The value of the destination vector
//                      element in the integer operations IPP_MAX_16S.
//    ippStsNoOperation Indicates an error when 0<val<1 is not true.
//  Notes:
//
*/
IPPAPI(IppStatus, ippsReflectionToAR_16s_Sfs, (const Ipp16s* pSrc,
       int srcShiftVal, Ipp16s* pDst, int len, int scaleFactor))

IPPAPI(IppStatus, ippsReflectionToAR_32f, (const Ipp32f* pSrc, Ipp32f* pDst,
       int len))

IPPAPI(IppStatus, ippsReflectionToLAR_16s_Sfs, (const Ipp16s* pSrc,
       int srcShiftVal, Ipp16s* pDst, int len, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsReflectionToLAR_32f, (const Ipp32f* pSrc,
       Ipp32f* pDst, int len, Ipp32f val))

IPPAPI(IppStatus, ippsReflectionToTrueAR_16s_Sfs, (const Ipp16s* pSrc,
       int srcShiftVal, Ipp16s* pDst, int len, int scaleFactor))

IPPAPI(IppStatus, ippsReflectionToTrueAR_32f, (const Ipp32f* pSrc,
       Ipp32f* pDst, int len))

/*/////////////////////////////////////////////////////////////////////////////
//  Name:              ippsPitchmarkToF0Cand_*
//  Purpose:           Calculates rise and fall amplitude and duration for tilt.
//
//  Parameters:
//    pSrc        Pointer to the input vector [len].
//    pDst        Pointer to the destination vector [len].
//    len         Length of the input and output vectors.
//
//  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.
//    ippStsDivByZero   Indicates a warning for zero-valued divisor vector
//                      element. Operation execution is not aborted. The value of
//                      the destination vector element in the floating-point
//                      operations +Inf. The value of the destination vector
//                      element in the integer operations IPP_MAX_16S.
//  Notes:
*/
IPPAPI(IppStatus, ippsPitchmarkToF0Cand_32f, (const Ipp32f* pSrc,
       Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsPitchmarkToF0Cand_16s_Sfs, (const Ipp16s* pSrc,
       Ipp16s* pDst, int len, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsUnitCurve_*_*
//
//  Purpose:      Calculates tilt for rise and fall coefficients.
//
//  Parameters:
//    pSrc        Pointer to the input array [len].
//    pSrcDst     Pointer to the input and destination vector [len].
//    pDst        Pointer to the output array [len].
//    len         Number of elements in the input vector.
//    srcShiftVal Input scale factor.
//    scaleFactor
//
//  Return:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr  Indicates an error when the pSrc, pSrcDst or pDst
//                      pointer is null.
//    ippStsSizeErr     Indicates an error when len is less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsUnitCurve_16s_Sfs, (const Ipp16s* pSrc, int srcShiftVal,
       Ipp16s* pDst, int len, int scaleFactor))

IPPAPI(IppStatus, ippsUnitCurve_32f, (const Ipp32f* pSrc,
       Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsUnitCurve_16s_ISfs, (Ipp16s* pSrcDst, int srcShiftVal,
       int len, int scaleFactor))

IPPAPI(IppStatus, ippsUnitCurve_32f_I, (Ipp32f* pSrcDst, int len))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLPToLSP_32f
//  Purpose:           computes linear spectral pairs from LPC (in the cosine domain).
//
//  Parameters:
//  pSrcLPC            Pointer to the input LPC coefficients vector [len].
//  pDstLSP            Pointer to the output LSP coefficients vector [len].
//  len                Number of LPC coefficients.
//  nRoots             Number of found LSP values.
//  nInt               Number of intervals while roots finding.
//  nDiv               Number of interval divisions while roots finding.
//  inScale            Scale factor for pSrcLPC values.
//  scaleFactor        Scale factor for pDstLSP values .
//  srcShiftVal        Scale factor for pSrcLP values .
//
//    Return:
// ippStsNoErr         Indicates no error.
// ippStsNullPtrErr    Indicates an error when the pSrc or  pDst pointer is null.
// ippStsSizeErr       Indicates an error when lenSrc or  len is less than or equal to 0
//                     or pSrc <  pDst.
// ippStsMemAllocErr   memory alllocation error
// ippStsNoRootFoundErr   if no decision exists2
*/
IPPAPI(IppStatus, ippsLPToLSP_32f,(const Ipp32f* pSrcLPC, Ipp32f* pDstLSP, int len,
        int* nRoots,int nInt, int nDiv))
IPPAPI(IppStatus, ippsLPToLSP_16s_Sfs,(const Ipp16s* pSrcLP, int srcShiftVal, Ipp16s* pDstLSP,
       int len,int* nRoots,int nInt, int nDiv, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLSPToLP_32f
//  Purpose:           computes linear spectral pairs from LPC (in the cosine domain).
//
//  Arguments:
//    pDstLPC        Pointer to the output LPC coefficients vector [len].
//    pSrcLSP        Pointer to the input LSP coefficients vector [len].
//    len            Number of LPC coefficients.
//    inScale        Scale factor for pSrcLPC values.
//    scaleFactor    Scale factor for pDstLSP values .
//
//  Return Value
//   ippStsNoErr      Indicates no error.
//   ippStsNullPtrErr Indicates an error when the pSrc or  pDst pointer is null.
//   ippStsSizeErr    Indicates an error when lenSrc or  len is less than or equal to 0
//                    or pSrc <  pDst.
//   ippStsMemAllocErr memory alllocation error
*/
IPPAPI(IppStatus, ippsLSPToLP_32f,(const Ipp32f* pSrcLSP, Ipp32f* pDstLPC, int len))
IPPAPI(IppStatus, ippsLSPToLP_16s_Sfs,(const Ipp16s* pSrcLSP, int srcShiftVal, Ipp16s* pDstLP,
         int len, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLPToSpectrum_32f
//  Purpose:           Computes first half of a LP magnitude spectrum
//    ippsLPToSpectrum_32f
//    Arguments:
//    pSrc        Pointer to the input LPC coefficients vector [len].
//    pDst        Pointer to the output LP spectrum coefficients vector [2order-1].
//    len         Number of LPC coefficients.
//    order       FFT order for spectrum calculation.
//    val         The value of add to spectrum.
//    scaleFactor Scale factor for pDst values .
//
// Return Value
//    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.
//    ippStsFftOrderErr  Indicates an error when the order value is incorrect.
//    ippStsDivByZero    Indicates a warning for zero-valued divisor vector element. Operation
//      execution is not aborted. The value of the destination vector element in the floating-point
//      operations is equal to +Inf : and in the integer operations is equal to IPP_MAX_16S.
*/

IPPAPI(IppStatus, ippsLPToSpectrum_32f,(const Ipp32f *LPCoeffs,int nLP,Ipp32f *pDst,
                                        int lenFFT,Ipp32f val))
IPPAPI(IppStatus, ippsLPToSpectrum_16s_Sfs,(const Ipp16s* pSrc, int len, Ipp16s* pDst, int order,
                                            Ipp32s val, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMelToLinear_32f
//  Purpose:           Converts Mel-scaled values to linear scale values.
//
//  Parameters:
//    pSrc             Pointer to the input vector [len]
//    pDst             Pointer to the output vector [len]
//    len              The length of input and output vectors
//    melMul           Multiply factor in the mel-scale equation
//    melDiv           Divide factor in the mel-scale equation
//
//    Return:
//    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,
//                        of melMul or melDiv is equal to 0.
*/

IPPAPI(IppStatus, ippsMelToLinear_32f,(const Ipp32f* pSrc, Ipp32f* pDst, int len,
       Ipp32f melMul, Ipp32f melDiv))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLinearToMel_32f
//  Purpose:           Converts linear-scale values to Mel-scale values.
//
//  Parameters:
//    pSrc             Pointer to the input vector [len]
//    pDst             Pointer to the output vector [len]
//    len              The length of input and output vectors
//    melMul           Multiply factor in the mel-scale equation
//    melDiv           Divide factor in the mel-scale equation
//
//  Return:
//    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,
//                        of melMul or melDiv is equal to 0.
//
*/
IPPAPI(IppStatus, ippsLinearToMel_32f,(const Ipp32f* pSrc, Ipp32f* pDst, int len,
       Ipp32f melMul, Ipp32f melDiv))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsCopyWithPadding_*
//  Purpose:           Copies the input signal to the output with zero padding
//  Parameters:
//    pSrc             Pointer to the input vector [lenSrc]
//    pDst             Pointer to the output vector [lenDst]
//    lenSrc           The length of pSrc vector.
//    lenDst           The length of pDst vector.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pDst pointer is null.
//    ippStsSizeErr    Indicates an error when lenSrc or lenDst is less than or
//                     equal to 0 or lenDst is less than lenSrc
*/


IPPAPI(IppStatus, ippsCopyWithPadding_16s,(const Ipp16s* pSrc, int lenSrc,
       Ipp16s* pDst, int lenDst))

IPPAPI(IppStatus, ippsCopyWithPadding_32f,(const Ipp32f* pSrc, int lenSrc,
       Ipp32f* pDst, int lenDst))

/* /////////////////////////////////////////////////////////////////////////////
// Name:            IppStatus ippsMelFBankGetSize_*  (int        winSize,
//                                                     int        nFilter,
//                                                     IppMelMode mode,
//                                                     int*        pSize))
//                  IppStatus ippsMelFBankGetSizeLow_Aurora_* (int* pSize)
//                  IppStatus ippsMelFBankGetSizeHigh_Aurora_* (int* pSize)
//
// Description:       Mel-frequency filter bank structure size - this function determines the
//                    size required for the Mel-frequency filter bank structure and associated
//                    storage. It should be called before memory allocation and before ippsMelFBankInit_32s.
//
// Input Arguments:   winSize - frame length in samples (32 = winSize = 8192).
//                    sampFreq - input signal sampling frequency Fs in Hz (0 < sampFreq = 48000).
//                    nFilter - number of Mel-scale filter banks K (0 < nFilter = winSize).
//                    mode - flag that determines the execution mode.  Currently only
//                           IPP_FBANK_FREQWGT is supported.
//
// Output Arguments:pSize - pointer to the variable to contain the size of the filter bank structure.
//
//
// Returns:           ippStsNoErr - No Error.
//                    ippStsFBankFlagErr - Indicates an error when the mode value is incorrect.
//                    ippStsNullPtrErr - Indicates an error when pSize pointer is null.
//                    ippStsSizeErr - Indicates an error when winSize, nFilter, or sampFreq is less than or equal to 0.
//
// Notes:
*/
IPPAPI(IppStatus, ippsMelFBankGetSize_32s,(int winSize, int nFilter,
       IppMelMode mode, int* pSize))

IPPAPI(IppStatus, ippsMelFBankGetSize_16s,(int winSize, int nFilter,
       IppMelMode mode, int* pSize))

IPPAPI(IppStatus, ippsMelFBankGetSize_32f,(int winSize, int nFilter,
       IppMelMode mode, int* pSize))

IPPAPI(IppStatus, ippsMelFBankGetSizeLow_Aurora_32f,(int* pSize))

IPPAPI(IppStatus, ippsMelFBankGetSizeHigh_Aurora_32f,(int* pSize))

IPPAPI(IppStatus, ippsMelFBankGetSizeLow_Aurora_16s,(int* pSize))

IPPAPI(IppStatus, ippsMelFBankGetSizeHigh_Aurora_16s,(int* pSize))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMelFBankInitAlloc_*
//  Purpose:           Initializes the structure for performing the Mel
//                     frequency filter bank analysis.
//  Parameters:
//      pFBank         Pointer to the Mel-scale filter bank structure to be created.
//      pFFTLen        Pointer to the order of FFT used for the filter bank evaluation.
//      winSize        Frame length (samples)
//      sampFreq       Input signal sampling frequency (in Hz)
//      lowFreq        Start frequency of the first band pass filter (in Hz)
//      highFreq       End frequency of the last band pass filter (in Hz)
//      nFilter        Number of Mel-scale filters banks K.
//      melMul         Mel-scale formula multiply factor.
//      melDiv         Mel-scale formula divisor.
//      mode           Flags that determine the execution mode; can have
//                            the following values:
//                            IPP_FBANK_MELWGT    - the function calculates filter bank
//                            weights in Mel-scale;
//                     IPP_FBANK_FREQWGT    - the function calculates filter bank
//                            weights in the frequency space.
//                            One of the above two flags should necessarily be set.
//                     IPP_POWER_SPECTRUM    - indicates that the FFT power
//                            spectrum is used during the filter bank analysis.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pFBank or pFFTLen pointer is null.
//    ippStsSizeErr    Indicates an error when winSize, nFilter, sampFreq, or
//                     lowFreqis less than or equal to 0.
//       ippStsFBankFreqErr Indicates an error when highFreqis less than lowFreqor
//                     highFreq is greater than sampFreq/2.
//       ippStsFBankFlagErr Indicates an error when the modevalue is incorrect.
//       ippStsMemAllocErr Indicates an error when no memory was allocated.
//
*/

IPPAPI(IppStatus, ippsMelFBankInitAlloc_16s,(IppsFBankState_16s** pFBank,
       int* pFFTLen, int winSize, Ipp32f sampFreq, Ipp32f lowFreq,
       Ipp32f highFreq, int nFilter, Ipp32f melMul, Ipp32f melDiv,
       IppMelMode mode))

IPPAPI(IppStatus, ippsMelFBankInitAlloc_32f,(IppsFBankState_32f** pFBank,
       int* pFFTLen, int winSize, Ipp32f sampFreq, Ipp32f lowFreq,
       Ipp32f highFreq, int nFilter, Ipp32f melMul, Ipp32f melDiv,
       IppMelMode mode))

IPPAPI(IppStatus, ippsMelFBankInitAllocLow_Aurora_32f,(IppsFBankState_32f** pFBank))

IPPAPI(IppStatus, ippsMelFBankInitAllocHigh_Aurora_32f,(IppsFBankState_32f** pFBank))

IPPAPI(IppStatus, ippsMelFBankInitAllocLow_Aurora_16s,(IppsFBankState_16s** pFBank))

IPPAPI(IppStatus, ippsMelFBankInitAllocHigh_Aurora_16s,(IppsFBankState_16s** pFBank))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMelFBankInit_*
//  Purpose:           Initializes the structure for performing the Mel
//                     frequency filter bank analysis.
//  Parameters:
//      pFBank         Pointer to the Mel-scale filter bank structure to be created.
//      pFFTLen        Pointer to the order of FFT used for the filter bank evaluation.
//      winSize        Frame length (samples)
//      sampFreq       Input signal sampling frequency (in Hz)
//      lowFreq        Start frequency of the first band pass filter (in Hz)
//      highFreq       End frequency of the last band pass filter (in Hz)
//      nFilter        Number of Mel-scale filters banks K.
//      melMul         Mel-scale formula multiply factor.
//      melDiv         Mel-scale formula divisor.
//      mode           Flags that determine the execution mode; can have
//                            the following values:
//                            IPP_FBANK_MELWGT    - the function calculates filter bank
//                            weights in Mel-scale;
//                     IPP_FBANK_FREQWGT    - the function calculates filter bank
//                            weights in the frequency space.
//                            One of the above two flags should necessarily be set.
//                     IPP_POWER_SPECTRUM    - indicates that the FFT power
//                            spectrum is used during the filter bank analysis.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pFBank or pFFTLen pointer is null.
//    ippStsSizeErr    Indicates an error when winSize, nFilter, sampFreq, or
//                     lowFreqis less than or equal to 0.
//       ippStsFBankFreqErr Indicates an error when highFreqis less than lowFreqor
//                     highFreq is greater than sampFreq/2.
//       ippStsFBankFlagErr Indicates an error when the modevalue is incorrect.
//       ippStsMemAllocErr Indicates an error when no memory was allocated.
//
*/

IPPAPI(IppStatus, ippsMelFBankInit_32s,(IppsFBankState_32s* pFBank,
       int* pFFTLen, int winSize, Ipp32s sampFreq,
       Ipp32s lowFreq, Ipp32s highFreq, int nFilter,
       Ipp32s melMulQ15, Ipp32s melDivQ15, IppMelMode mode))

IPPAPI(IppStatus, ippsMelFBankInit_16s,(IppsFBankState_16s* pFBank,
       int* pFFTLen, int winSize, Ipp32f sampFreq, Ipp32f lowFreq,
       Ipp32f highFreq, int nFilter, Ipp32f melMul, Ipp32f melDiv,
       IppMelMode mode))

IPPAPI(IppStatus, ippsMelFBankInit_32f,(IppsFBankState_32f* pFBank,
       int* pFFTLen, int winSize, Ipp32f sampFreq, Ipp32f lowFreq,
       Ipp32f highFreq, int nFilter, Ipp32f melMul, Ipp32f melDiv,
       IppMelMode mode))

IPPAPI(IppStatus, ippsMelFBankInitLow_Aurora_32f,(IppsFBankState_32f* pFBank))

IPPAPI(IppStatus, ippsMelFBankInitHigh_Aurora_32f,(IppsFBankState_32f* pFBank))

IPPAPI(IppStatus, ippsMelFBankInitLow_Aurora_16s,(IppsFBankState_16s* pFBank))

IPPAPI(IppStatus, ippsMelFBankInitHigh_Aurora_16s,(IppsFBankState_16s* pFBank))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMelLinFBankInitAlloc_*
//  Purpose:           Initializes the linear and mel-frequency filter banks
//   Parameters:
//    pFBank           Pointer to the mel scale filter bank structure to be created.
//    FFTLen           Pointer to the length of FFT N used for filter bank evaluation.
//    winSize          Frame length (samples)
//    sampFreq         Input signal sampling frequency   (in Hz)
//    lowFreq          Start frequency  of the first band pass filter (in Hz)
//    highLinFreq      End frequency  of the last band pass filter on linear
//                     scale (in Hz)
//    highFreq         End frequency  of the last band pass filter (in Hz)
//    nFilter          Number of Mel-scale filters   in the filter bank
//    nLinFilter       umber of Linear-scale filters   in the filter bank
//    melMul           Mel scale formula factor
//    melDiv           Mel scale formula divisor
//    mode             One of the following values:
//                     IPP_FBANK_MELWGT - calculate fbank weights in Mel-scale
//                     IPP_FBANK_FREQWGT - calculate fbank weights in
//                     frequency space
//                     IPP_POWER_SPECTRUM - indicates that FFT power logarithm
//                     of input signal is calculated before filter bank
//                     evaluation by ippsEvalFBank function.
//                     Corresponding internal structures are initialized in
//                     the result filter bank structure.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsSizeErr    Indicates an error when winSize, nFilter, nLinFilter,
//                     freq, lowFreq is less than or equal to 0 or nLinFilter
//                     is greater than nFilter;
//    ippStsFBankFreqErr Indicates an error when (lowFreq > highlinFreq)
//                     or (highlinFreq > highFreq) or (highFreq > sampFreq/2)
//                     or (highLinFreq> lowFreq)&&(nLinFilter==0)
//                     or (highLinFreq< highFreq)&&(nLinFilter==nFilter)
//    ippStsFBankFlagErr Indicates an error when the mode value is incorrect.
//    ippStsMemAllocErr Indicates an error when no memory allocated.
*/

IPPAPI(IppStatus, ippsMelLinFBankInitAlloc_32f,(IppsFBankState_32f** pFBank,
       int* pFFTLen, int winSize, Ipp32f sampFreq, Ipp32f lowFreq,
       Ipp32f highFreq, int nFilter, Ipp32f highLinFreq, int nLinFilter,
       Ipp32f melMul, Ipp32f melDiv, IppMelMode mode))

IPPAPI(IppStatus, ippsMelLinFBankInitAlloc_16s,(IppsFBankState_16s** pFBank,
       int* pFFTLen, int winSize, Ipp32f sampFreq, Ipp32f lowFreq,
       Ipp32f highFreq, int nFilter, Ipp32f highLinFreq, int nLinFilter,
       Ipp32f melMul, Ipp32f melDiv, IppMelMode mode))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsEmptyFBankInitAlloc_*
//  Purpose:           Initializes an empty filter bank structure.
//  Parameters:
//    pFBank           Pointer to the filter bank structure to be created.
//    pFFTLen          Pointer to the order of FFT used for the
//                     filter bank evaluation.
//    winSize          Frame length (samples)
//    nFilter          Number of filters banks K.
//    mode             Flag determining the function's execution mode; can have
//                     the following value:
//                     IPP_POWER_SPECTRUM - indicates that the logarithm of the
//                     FFT power spectrum is used during the filter
//                     bank analysis.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pFBank or pFFTLen pointer is null.
//    ippStsSizeErr    Indicates an error when winSize or nFilter or pFBank
//                     is less than or equal to 0;
//    ippStsMemAllocErr Indicates an error when no memory allocated.
//
*/
IPPAPI(IppStatus, ippsEmptyFBankInitAlloc_32f,(IppsFBankState_32f** pFBank, int* pFFTLen,
       int winSize, int nFilter, IppMelMode mode))

IPPAPI(IppStatus, ippsEmptyFBankInitAlloc_16s,(IppsFBankState_16s** pFBank, int* pFFTLen,
       int winSize, int nFilter, IppMelMode mode))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsFBankFree_*
//  Purpose:           Destroys the structure for the filter bank analysis.
//  Parameters:
//    pFBank           Pointer to the filter bank structure.
//
//  Return:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pFBank pointer is null.
*/
IPPAPI(IppStatus, ippsFBankFree_16s,(IppsFBankState_16s* pFBank))

IPPAPI(IppStatus, ippsFBankFree_32f,(IppsFBankState_32f* pFBank))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsFBankGetCenters_*
//  Purpose:           Retrieves the center frequencies of the
//                     triangular filter banks.
//  Parameters:
//    pFBank           Pointer to the filter bank structure.
//    pCenters         Pointer to the output vector that contains the center
//                     frequencies.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pFBank or pCenters pointer is null.
//    ippStsFBankErr   Indicates an error when filter centers are not valid after filter
//                     bank initialization by ippsEmptyFBankInitAlloc function.
//
*/

IPPAPI(IppStatus, ippsFBankGetCenters_32f,(const IppsFBankState_32f* pFBank, int* pCenters))

IPPAPI(IppStatus, ippsFBankGetCenters_16s,(const IppsFBankState_16s* pFBank, int* pCenters))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsFBankSetCenters_*
//  Purpose:           Sets the center frequencies of the
//                     triangular filter banks.
//  Parameters:
//    pFBank           Pointer to the filter bank structure
//    pCenters         Pointer to the vector that contains center frequencies.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pFBank or pCenters pointer is null.
//
*/

IPPAPI(IppStatus, ippsFBankSetCenters_16s,(IppsFBankState_16s* pFBank,
       const int* pCenters))

IPPAPI(IppStatus, ippsFBankSetCenters_32f,(IppsFBankState_32f* pFBank,
       const int* pCenters))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsFBankGetCoeffs_*
//  Purpose:           Retrieves the filter bank weight coefficients.
//  Parameters:
//    pFBank           Pointer to the filter bank structure
//    fIdx             Filter index.
//    pCoeffs          Pointer to the filter coefficients vector.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pFBank or pCoeffs pointer is null.
//    ippStsSizeErr    Indicates an error when fIdx is less then 1 or greater
//                     then nFilter.
//    ippStsFBankErr   Indicates an error when fIdx filter coeffitients are not
//                     valid after filter centers reset or filter centers are not
//                     valid after filter bank initialization by
//                     ippsEmptyFBankInitAlloc function.
//
*/

IPPAPI(IppStatus, ippsFBankGetCoeffs_16s,(const IppsFBankState_16s* pFBank,
       int fIdx, Ipp32f* pCoeffs))

IPPAPI(IppStatus, ippsFBankGetCoeffs_32f,(const IppsFBankState_32f* pFBank,
       int fIdx, Ipp32f* pCoeffs))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsFBankSetCoeffs_*
//  Purpose:           Sets the filter bank weight coefficients.
//  Parameters:
//    pFBank           Pointer to the filter bank structure
//    fIdx             Filter index.
//    pCoeffs          Pointer to the output coefficients vector.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pFBank or pCoeffs pointer is null.
//    ippStsSizeErr    Indicates an error when fIdx is less then 1 or greater
//                     then nFilter.
//    ippStsFBankErr   Indicates an error when the weight coefficients are not
//                     available or valid.
//
*/
IPPAPI(IppStatus, ippsFBankSetCoeffs_16s,(IppsFBankState_16s* pFBank, int fIdx,
       const Ipp32f* pCoeffs))

IPPAPI(IppStatus, ippsFBankSetCoeffs_32f,(IppsFBankState_32f* pFBank, int fIdx,
       const Ipp32f* pCoeffs))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsEvalFBank_*
//  Purpose:           Performs the filter bank analysis
//  Parameters:
//    pSrc             Pointer to the source vector
//    pDst             Pointer to the filter bank coefficients vector [nFilter].
//    pFBank           Pointer to the filter bank structure.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pDst pointer is null.
//    ippStsFBankErr   Indicates an error when pFBank structure is not ready for
//                     calculation.
//
*/

IPPAPI(IppStatus, ippsEvalFBank_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
       const IppsFBankState_16s* pFBank, int scaleFactor))

IPPAPI(IppStatus, ippsEvalFBank_16s32s_Sfs,(const Ipp16s* pSrc, Ipp32s* pDst,
       const IppsFBankState_16s* pFBank, int scaleFactor))

IPPAPI(IppStatus, ippsEvalFBank_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
       const IppsFBankState_32f* pFBank))

IPPAPI(IppStatus, ippsEvalFBank_32s_Sfs,(const Ipp32s* pSrc, Ipp32s* pDst,
       const IppsFBankState_32s*    pFBank, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDCTLifterGetSize_*
//  Purpose:           This function determines the
//                     size required for initializes the structure to perform DCT
//                     and lift the DCT coefficients. It should be called before
//                     memory allocation and before ippsDCTLifterInit_*
//  Parameters:
//    lenDCT           Length of DCT will be used for MFCC calculation
//    lenCeps          Number (without c0) of cepstral coefficients to be calculated.
//    nLifter          Liftering factor
//    pSize            output
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSize pointer is null.
//    ippStsSizeErr    Indicates an error when lenDCT, lenCeps or nLifter is
//                     less than or equal to 0 or lenDCT is less than lenCeps.
//
*/

IPPAPI(IppStatus, ippsDCTLifterGetSize_32f,(int lenDCT, int lenCeps, int *pSize))

IPPAPI(IppStatus, ippsDCTLifterGetSize_C0_32f,(int lenDCT, int lenCeps, int *pSize))

IPPAPI(IppStatus, ippsDCTLifterGetSize_Mul_32f,(int lenDCT, int lenCeps, int *pSize))

IPPAPI(IppStatus, ippsDCTLifterGetSize_MulC0_32f,(int lenDCT, int lenCeps, int *pSize))

IPPAPI(IppStatus, ippsDCTLifterGetSize_16s,(int lenDCT, int lenCeps, int *pSize))

IPPAPI(IppStatus, ippsDCTLifterGetSize_C0_16s,(int lenDCT, int lenCeps, int *pSize))

IPPAPI(IppStatus, ippsDCTLifterGetSize_Mul_16s,(int lenDCT, int lenCeps, int *pSize))

IPPAPI(IppStatus, ippsDCTLifterGetSize_MulC0_16s,(int lenDCT, int lenCeps, int* pSize))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDCTLifterInit_*
//  Purpose:           Initializes the structure to perform DCT
//                     and lift the DCT coefficients.
//  Parameters:
//    pDCTLifter       Pointer to the created structure for DCT calculation and
//                     liftering.
//    lenDCT           Length of DCT will be used for MFCC calculation
//    lenCeps          Number (without c0) of cepstral coefficients to be calculated.
//    nLifter          Liftering factor
//    pLifter          Pointer to liftering coefficients vector
//    val              Value to multiply output MFCC except c0 coefficient
//    val0             Value to multiply output c0 coefficient
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pLifter pointer is null.
//    ippStsSizeErr    Indicates an error when lenDCT, lenCeps or nLifter is
//                     less than or equal to 0 or lenDCT is less than lenCeps.
//    ippStsMemAllocErr    Indicates an error when no memory allocated.
//
*/

IPPAPI(IppStatus, ippsDCTLifterInit_32f,(IppsDCTLifterState_32f* pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val))

IPPAPI(IppStatus, ippsDCTLifterInit_C0_32f,(IppsDCTLifterState_32f* pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val, Ipp32f val0))

IPPAPI(IppStatus, ippsDCTLifterInit_Mul_32f,(IppsDCTLifterState_32f* pDCTLifter,
       int lenDCT, const Ipp32f* pLifter, int lenCeps))

IPPAPI(IppStatus, ippsDCTLifterInit_MulC0_32f,(IppsDCTLifterState_32f* pDCTLifter,
       int lenDCT, const Ipp32f* pLifter, int lenCeps))

IPPAPI(IppStatus, ippsDCTLifterInit_16s,(IppsDCTLifterState_16s* pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val))

IPPAPI(IppStatus, ippsDCTLifterInit_C0_16s,(IppsDCTLifterState_16s* pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val, Ipp32f val0))

IPPAPI(IppStatus, ippsDCTLifterInit_Mul_16s,(IppsDCTLifterState_16s* pDCTLifter,
       int lenDCT, const Ipp32f* pLifter, int lenCeps))

IPPAPI(IppStatus, ippsDCTLifterInit_MulC0_16s,(IppsDCTLifterState_16s* pDCTLifter,
       int lenDCT, const Ipp32s* pLifter, int lenCeps))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDCTLifterInitAlloc_MulC0_*
//  Purpose:           Initializes the structure to perform DCT
//                     and lift the DCT coefficients.
//  Parameters:
//    pDCTLifter       Pointer to the created structure for DCT calculation and
//                     liftering.
//    lenDCT           Length of DCT will be used for MFCC calculation
//    lenCeps          Number (without c0) of cepstral coefficients to be calculated.
//    nLifter          Liftering factor
//    pLifter          Pointer to liftering coefficients vector
//    val              Value to multiply output MFCC except c0 coefficient
//    val0             Value to multiply output c0 coefficient
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pLifter pointer is null.
//    ippStsSizeErr    Indicates an error when lenDCT, lenCeps or nLifter is
//                     less than or equal to 0 or lenDCT is less than lenCeps.
//    ippStsMemAllocErr    Indicates an error when no memory allocated.
//
*/

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_32f,(IppsDCTLifterState_32f** pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val))

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_C0_32f,(IppsDCTLifterState_32f** pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val, Ipp32f val0))

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_Mul_32f,(IppsDCTLifterState_32f** pDCTLifter,
       int lenDCT, const Ipp32f* pLifter, int lenCeps))

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_MulC0_32f,(IppsDCTLifterState_32f** pDCTLifter,
       int lenDCT, const Ipp32f* pLifter, int lenCeps))

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_16s,(IppsDCTLifterState_16s** pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val))

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_C0_16s,(IppsDCTLifterState_16s** pDCTLifter,
       int lenDCT, int lenCeps, int nLifter, Ipp32f val, Ipp32f val0))

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_Mul_16s,(IppsDCTLifterState_16s** pDCTLifter,
       int lenDCT, const Ipp32f* pLifter, int lenCeps))

IPPAPI(IppStatus, ippsDCTLifterInitAlloc_MulC0_16s,(IppsDCTLifterState_16s** pDCTLifter,
       int lenDCT, const Ipp32f* pLifter, int lenCeps))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDCTLifterFree_*
//  Purpose:           Destroys the structure for DCT and liftering
//  Parameters:
//    pDCTLifter       Pointer to the filter bank structure
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pDCTLifter pointer is null.
//
*/

IPPAPI(IppStatus, ippsDCTLifterFree_32f,(IppsDCTLifterState_32f* pDCTLifter))

IPPAPI(IppStatus, ippsDCTLifterFree_16s,(IppsDCTLifterState_16s* pDCTLifter))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDCTLifter_*
//  Purpose:           Performs DCT and lifts the DCT coefficients.
//  Parameters:
//    pSrc             Pointer to the filter output vector [lenDCT]
//    pDst             Pointer to the MFCC feature vector.
//    pDCTLifter       Pointer to the filter bank structure
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicate an error when the pSrc, pDst, pFBank pointer is null.
//
*/

IPPAPI(IppStatus, ippsDCTLifter_32f,(const Ipp32f* pSrc, Ipp32f* pDst,
       const IppsDCTLifterState_32f* pDCTLifter))

IPPAPI(IppStatus, ippsDCTLifter_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
       const IppsDCTLifterState_16s* pDCTLifter, int scaleFactor))

IPPAPI(IppStatus, ippsDCTLifter_32s16s_Sfs, (const Ipp32s* pSrc, Ipp16s* pDst,
       const IppsDCTLifterState_16s* pDCTLifter, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsNormEnergy_*
//  Purpose:           Normalizes a vector of energy values.
//  Parameters:
//    pSrcDst          Pointer to the input/output vector [height*step].
//    step             Sample step in the vector pSrcDst.
//    height           Number of samples for normalization
//    silFloor         Silence floor in log10 value
//    val              Coefficient value.
//    maxE             Maximum energy value
//    enScale          Energy scale
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcDst pointer is null.
//    ippStsSizeErr    Indicates an error when step or height is less than
//                     or equal to 0
//
*/

IPPAPI(IppStatus, ippsNormEnergy_32f,(Ipp32f* pSrcDst, int step, int height,
       Ipp32f silFloor, Ipp32f enScale))

IPPAPI(IppStatus, ippsNormEnergy_16s,(Ipp16s* pSrcDst, int step, int height,
       Ipp16s silFloor, Ipp16s val, Ipp32f enScale))

IPPAPI(IppStatus, ippsNormEnergy_RT_32f,(Ipp32f* pSrcDst, int step, int height,
       Ipp32f silFloor, Ipp32f maxE, Ipp32f enScale))

IPPAPI(IppStatus, ippsNormEnergy_RT_16s,(Ipp16s* pSrcDst, int step, int height,
       Ipp16s silFloor, Ipp16s maxE, Ipp16s val, Ipp32f enScale))

/*/////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSumMeanVar_*
//  Purpose:           The function sums the vector elements and their
//                     squares according.
//
//  Parameters:
//    pSrc             Pointer to the source vector [height* srcStep].
//    pDstMean         Pointer to the result vector that contains sums [width].
//    pdstVar          Pointer to the result vector that contains square sums [width].
//    width            Number of columns in the pSrc.
//    srcStep          Row step in pSrc.
//    height           Number of rows in pSrc.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pDstMean, pDstVar,
//                     pSrcDstMean or pSrcDstVar pointer is null.
//    ippStsSizeErr    Indicates an error when srcStep, width or height is less
//                     than or equal to 0 or width is greater than srcStep;
//
*/

IPPAPI(IppStatus,ippsSumMeanVar_32f,(const Ipp32f* pSrc, int srcStep, int height,
       Ipp32f* pDstMean, Ipp32f* pDstVar, int width))

IPPAPI(IppStatus,ippsSumMeanVar_16s32f,(const Ipp16s* pSrc, int srcStep,
       int height, Ipp32f* pDstMean, Ipp32f* pDstVar, int width))

IPPAPI(IppStatus,ippsSumMeanVar_16s32s_Sfs,(const Ipp16s* pSrc, int srcStep,
       int height, Ipp32s* pDstMean, Ipp32s* pDstVar, int width, int scaleFactor))

IPPAPI(IppStatus,ippsSumMeanVar_32f_I,(const Ipp32f* pSrc, int srcStep,
       int height, Ipp32f* pSrcDstMean, Ipp32f* pSrcDstVar, int width))

IPPAPI(IppStatus,ippsSumMeanVar_16s32f_I,(const Ipp16s* pSrc, int srcStep,
       int height, Ipp32f* pSrcDstMean, Ipp32f* pSrcDstVar, int width))

IPPAPI(IppStatus,ippsSumMeanVar_16s32s_ISfs,(const Ipp16s* pSrc, int srcStep,
       int height, Ipp32s* pSrcDstMean, Ipp32s* pSrcDstVar, int width,
       int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsNewVar_*
//  Purpose:           The function computes the variance vector.
//
//  Parameters:
//    pSrcMean         Pointer to the source vector of element sums [width].
//    pSrcVar          Pointer to the source vector of element sum squares [width].
//    pSrcDstVar       Pointer to the source and result vector of element sum squares [width].
//    width            Number of columns in the pSrc.
//    val1, val2       Multiplicative constants.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcMean, pSrcVar, pDstVar or
//                     pSrcDstVar pointer is null.
//    ippStsSizeErr    Indicates an error when width is less than or equal to 0;
//
*/



IPPAPI(IppStatus, ippsNewVar_32s_Sfs,(const Ipp32s* pSrcMean,
       const Ipp32s* pSrcVar, Ipp32s* pDstVar, int width, Ipp32f val1,
       Ipp32f val2, int scaleFactor))

IPPAPI(IppStatus, ippsNewVar_32s_ISfs,(const Ipp32s* pSrcMean,
       Ipp32s* pSrcDstVar, int width, Ipp32f val1, Ipp32f val2, int scaleFactor))

IPPAPI(IppStatus, ippsNewVar_32f,(const Ipp32f* pSrcMean, const Ipp32f* pSrcVar,
       Ipp32f* pDstVar, int width, Ipp32f val1, Ipp32f val2))

IPPAPI(IppStatus, ippsNewVar_32f_I,(const Ipp32f* pSrcMean, Ipp32f* pSrcDstVar,
       int width, Ipp32f val1, Ipp32f val2))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsRecSqrt_*
//  Purpose:           Computes square root reciprocals of vector
//                     elements in-place.
//  Parameters:
//      pSrcDst        Pointer to the source and destination vector pSrcDst.
//      len            The number of elements in the vector.
//      val            The threshold factor.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcDst pointer is null.
//    ippStsInvByZero  Indicates an error when pSrcDst[i]is less than val.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0.
//    ippStsBadArgErr  Indicates an error when val is less than or equal to 0
//
*/
IPPAPI(IppStatus,ippsRecSqrt_32s_Sfs,(Ipp32s* pSrcDst, int len,Ipp32s val,
       int scaleFactor))

IPPAPI(IppStatus,ippsRecSqrt_32s16s_Sfs,(const Ipp32s* pSrc, Ipp16s* pDst, int len,Ipp32s val,
       int scaleFactor))

IPPAPI(IppStatus, ippsRecSqrt_32f, (Ipp32f* pSrcDst, int len, Ipp32f val))


/*//////////////////////////////////////////////////////////////////////
// Name:                ippsAccCovarianceMatrix_*
// Purpose:             Accumulate covariance matrix.
// Parameters:
//    pSrc              Pointer to the input vector [height*srcStep].
//    mSrc              Pointer to the input matrix [height][width].
//    srcStep           Row step in pSrc.
//    pMean             Pointer to the mean vector [width].
//    width             Length of the input matrix row, mean, and variance vectors.
//    pSrcDst           Pointer to the source and result matrix [width*dstStep].
//    mSrcDst           Pointer to the source and result matrix [width][width].
//    dstStep           Row step in pDst.
//    height            Number of rows in the input matrix.
//    val               Value to multiply to each distance.
// Return:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr  Indicates an error when the pSrc, mSrc, pMean, pSrcDst,
//                      or mSrcDst pointer is null.
//    ippStsSizeErr     Indicates an error when width or height is less than
//                      or equal to 0.
//    ippStsStrideErr   Indicates an error when srcStep or dstStep is less
//                      than width.
*/
IPPAPI(IppStatus, ippsAccCovarianceMatrix_16s64f_D2L,(const Ipp16s** mSrc,
       int height, const Ipp16s* pMean, Ipp64f** mSrcDst, int width, Ipp64f val))

IPPAPI(IppStatus, ippsAccCovarianceMatrix_32f64f_D2L, (const Ipp32f** mSrc,
       int height, const Ipp32f* pMean, Ipp64f** mSrcDst, int width, Ipp64f val))

IPPAPI(IppStatus, ippsAccCovarianceMatrix_16s64f_D2, (const Ipp16s* pSrc,
       int srcStep, int height, const Ipp16s* pMean, Ipp64f* pSrcDst, int width,
       int dstStep, Ipp64f val))

IPPAPI(IppStatus, ippsAccCovarianceMatrix_32f64f_D2, (const Ipp32f* pSrc,
       int srcStep, int height, const Ipp32f* pMean, Ipp64f* pSrcDst, int width,
       int dstStep, Ipp64f val))

/* /////////////////////////////////////////////////////////////////////////////
//  Derivatives
/////////////////////////////////////////////////////////////////////////////
*/
/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsCopyColumn_*_D2
//  Purpose:           Copies the input sequence into the output sequence.
//  Parameters:
//    pSrc             Pointer to the input feature sequence [height*srcWidth].
//    srcWidth         Length of each input feature vector.
//    pDst             Pointer to the output feature sequence [height*dstWidth].
//    dstWidth         Length of each output feature vector.
//    height           Number of features in the sequence.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pDst pointer is null.
//    ippStsSizeErr    Indicates an error when height or srcWidth is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when dstWidth is less than srcWidth.
*/
IPPAPI(IppStatus, ippsCopyColumn_16s_D2, (const Ipp16s* pSrc, int srcWidth,
       Ipp16s* pDst, int dstWidth, int height))

IPPAPI(IppStatus, ippsCopyColumn_32f_D2, (const Ipp32f* pSrc, int srcWidth,
       Ipp32f* pDst, int dstWidth, int height))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsEvalDelta_D2
//  Purpose:           Computes the derivatives of vector elements.
//
//  Parameters:
//    pSrcDst          Pointer to the input and output vector [height*step].
//    height           The number of rows in pSrcDst.
//    step             Length of each feature in pSrcDst
//    width            The number of derivatives to be calculated for each feature.
//    offset           Offset to place the derivative values.
//    winSize          The delta window size
//    val              The delta coefficient.
//    pVal             Pointer to the delta coefficients vector [width].
//    scaleFactor
//
//  Return:
//    ippStsNoErr          Indicates no error.
//    ippStsNullPtrErr     Indicates an error when the pSrcDst pointer is null.
//    ippStsSizeErr        Indicates an error when height, width, or winSize
//                         is less than or equal to 0 or offset is less than 0
//                         or width is less than or equal to offset or height is
//                         less than 2*winSize.
//    ippStsStrideErr      Indicates an error when step is less than offset+2*width.
*/

IPPAPI(IppStatus, ippsEvalDelta_16s_D2Sfs, (Ipp16s*pSrcDst, int height, int step,
       int width, int offset, int winSize, Ipp16s val, int scaleFactor))

IPPAPI(IppStatus, ippsEvalDelta_32f_D2, (Ipp32f *pSrcDst, int height, int step,
       int width, int offset, int winSize, Ipp32f val))

IPPAPI(IppStatus, ippsEvalDeltaMul_16s_D2Sfs, (Ipp16s* pSrcDst, int height,
       int step, const Ipp16s* pVal, int width, int offset, int winSize,
       int scaleFactor))

IPPAPI(IppStatus, ippsEvalDeltaMul_32f_D2, (Ipp32f* pSrcDst, int height,
       int step, const Ipp32f* pVal, int width, int offset, int winSize))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDelta*_D2
//  Purpose:           Copies the base features and calculates the
//                     derivatives of feature vectors.
//  Parameters:
//    pSrc             Pointer to the source vector [height*srcWidth].
//    srcWidth         The number of columns in the pSrc.
//    pDst             Pointer to the result vector [height*dstStep].
//    dstStep          The row step in pDst.
//    val              The delta coefficient.
//    height           Number of feature vectors.
//    deltaMode        Execution mode.
//    pVal             Pointer to the delta coefficients vector [width].
//    scaleFactor
//
//    ippStsNoErr         Indicates no error.
//    ippStsNullPtrErr    Indicates an error when the pSrc, pDst or pVal pointer is null.
//    ippStsSizeErr       Indicates an error when srcWidth is less than or equal to 0;
//                          or height is less than 0;
//                          or height is less than 2*winSize when deltaMode is equal to IPP_DELTA_BEGIN;
//                          or height is equal to 0 when deltaMode is not equal to IPP_DELTA_END.
//    ippStsStrideErr     Indicates an error when dstStep is less than 2*srcWidth.
*/

IPPAPI(IppStatus, ippsDelta_Win1_16s_D2Sfs, (const Ipp16s* pSrc, int srcWidth,
       Ipp16s*  pDst, int dstStep, int height, Ipp16s val,  int deltaMode,
       int scaleFactor))

IPPAPI(IppStatus, ippsDelta_Win2_16s_D2Sfs, (const Ipp16s* pSrc, int srcWidth,
       Ipp16s*  pDst, int dstStep, int height, Ipp16s val, int deltaMode,
       int scaleFactor))

IPPAPI(IppStatus, ippsDelta_Win1_32f_D2, (const Ipp32f* pSrc, int srcWidth,
       Ipp32f*  pDst, int dstStep, int height, Ipp32f val, int deltaMode))

IPPAPI(IppStatus, ippsDelta_Win2_32f_D2, (const Ipp32f* pSrc, int srcWidth,
       Ipp32f*  pDst, int dstStep, int height, Ipp32f val, int deltaMode))

IPPAPI(IppStatus, ippsDeltaMul_Win1_16s_D2Sfs, (const Ipp16s* pSrc,
       const Ipp16s* pVal, int srcWidth, Ipp16s* pDst, int dstStep,
       int height, int deltaMode, int scaleFactor))

IPPAPI(IppStatus, ippsDeltaMul_Win2_16s_D2Sfs, (const Ipp16s* pSrc,
       const Ipp16s* pSrc1, int srcWidth, Ipp16s* pDst, int dstStep,
       int height, int deltaMode, int scaleFactor))

IPPAPI(IppStatus, ippsDeltaMul_Win1_32f_D2, (const Ipp32f* pSrc,
       const Ipp32f* pVal, int srcWidth, Ipp32f* pDst, int dstStep,
       int height, int deltamode))

IPPAPI(IppStatus, ippsDeltaMul_Win2_32f_D2, (const Ipp32f* pSrc,
       const Ipp32f* pVal, int srcWidth, Ipp32f* pDst, int dstStep,
       int height, int deltamode))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDeltaDelta*_D2
//  Purpose:           Copies the base features and calculates their first
//                     and second derivatives.
//  Parameters:
//    pSrc             Pointer to the source vector [height*srcWidth].
//    srcWidth         Length of the input feature in the input sequence pSrc.
//    pDst             Pointer to the result vector [height*dstStep].
//    dstStep          The row step in pDst.
//    height           The number of rows in pSrc and pDst.
//    val1, val2       The first and second delta coefficients.
//    deltaMode        Execution mode.
//    pVal             Pointer to the delta coefficients vector [width].
//  scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pDst pointer is null.
//    ippStsSizeErr    Indicates an error when srcWidth is less than or equal to 0;
//                         or height is less than 0;
//                         or height is less than 3*winSize when deltaMode is equal to IPP_DELTA_BEGIN;
//                         or height is equal to 0 when deltaMode is not equal to IPP_DELTA_END.
//    ippStsStrideErr  Indicates an error when dstStep is less than 3*srcWidth.
*/

IPPAPI(IppStatus, ippsDeltaDelta_Win1_16s_D2Sfs, (const Ipp16s* pSrc, int srcWidth,
       Ipp16s* pDst, int dstStep, int height, Ipp16s val1,
       Ipp16s val2, int deltaMode, int scaleFactor))

IPPAPI(IppStatus, ippsDeltaDelta_Win2_16s_D2Sfs, (const Ipp16s* pSrc, int srcWidth,
       Ipp16s* pDst, int dstStep, int height, Ipp16s val1,
       Ipp16s val2, int deltaMode, int scaleFactor))

IPPAPI(IppStatus, ippsDeltaDeltaMul_Win1_16s_D2Sfs, (const Ipp16s* pSrc,
       const Ipp16s* pVal, int srcWidth, Ipp16s* pDst, int dstStep, int height,
       int deltamode, int scaleFactor))

IPPAPI(IppStatus, ippsDeltaDeltaMul_Win2_16s_D2Sfs, (const Ipp16s* pSrc,
       const Ipp16s* pVal, int srcWidth, Ipp16s* pDst, int dstStep, int height,
       int deltamode, int scaleFactor))

IPPAPI(IppStatus, ippsDeltaDeltaMul_Win1_32f_D2, (const Ipp32f* pSrc,
       const Ipp32f* pSrc1, int srcWidth, Ipp32f* pDst, int dstStep, int height,
       int deltamode))

IPPAPI(IppStatus, ippsDeltaDeltaMul_Win2_32f_D2, (const Ipp32f* pSrc,
       const Ipp32f* pSrc1, int srcWidth, Ipp32f* pDst, int dstStep, int height,
       int deltamode))

IPPAPI(IppStatus, ippsDeltaDelta_Win1_32f_D2, (const Ipp32f* pSrc, int srcWidth,
       Ipp32f* pDst, int dstStep, int height, Ipp32f val1,
       Ipp32f val2, int deltaMode))

IPPAPI(IppStatus, ippsDeltaDelta_Win2_32f_D2, (const Ipp32f* pSrc, int srcWidth,
       Ipp32f* pDst, int dstStep, int height, Ipp32f val1,
       Ipp32f val2, int deltaMode))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsDeltaDelta_Aurora_*
//  Purpose:        The function ippsDeltaDelta_Aurora calculate full feature vectors
//                  according to ETSI ES 202 050 standard.
//  Context:
//  Returns:
//           ippStsNoErr      Indicates no error.
//           ippStsNullPtrErr Indicates an error when pSrc, pDst, or pVal pointer is NULL.
//                  ippStsSizeErr    Indicates an error when height is less than 0;
//                              or height is less than 8 when deltaMode is equal to IPP_DELTA_BEGIN;
//                              or height is equal to 0 when deltaMode is not equal to IPP_DELTA_END.
//           ippStsStrideErr  Indicates an error when dstStep is less than 39.
//  Parameters:
//      pSrc        Pointer to the input feature sequence [height*14].
//      pDst        Pointer to the output feature sequence [height*dstStep].
//      dstStep     Length of the output feature in the output sequence pDst.
//      height      Number of feature vectors.
//      deltaMode   Execution mode.
//      pVal        Pointer to the delta coefficients vector [39].
//      scaleFactor Refer to "Integer Scaling" in Chapter 2.
//  Notes:
*/

IPPAPI(IppStatus,ippsDeltaDelta_Aurora_16s_D2Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
                int dstStep, int height, int deltaMode, int scaleFactor))

IPPAPI(IppStatus,ippsDeltaDelta_Aurora_32f_D2,(const Ipp32f* pSrc, Ipp32f* pDst,
                int dstStep, int height, int deltaMode))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsDeltaDeltaMul_Aurora_*
//  Purpose:        The function ippsDeltaDelta_Aurora calculate full feature vectors
//                  according to ETSI ES 202 050 standard.
//  Context:
//  Returns:
//                  ippStsNoErr      Indicates no error.
//                  ippStsNullPtrErr Indicates an error when pSrc, pDst, or pVal pointer is NULL.
//                  ippStsSizeErr    Indicates an error when height is less than 0;
//                              or height is less than 8 when deltaMode is equal to IPP_DELTA_BEGIN;
//                              or height is equal to 0 when deltaMode is not equal to IPP_DELTA_END.
//                  ippStsStrideErr  Indicates an error when dstStep is less than 39.
//  Parameters:
//      pSrc        Pointer to the input feature sequence [height*14].
//      pDst        Pointer to the output feature sequence [height*dstStep].
//      dstStep     Length of the output feature in the output sequence pDst.
//      height      Number of feature vectors.
//      deltaMode   Execution mode.
//      pVal        Pointer to the delta coefficients vector [39].
//      scaleFactor Refer to "Integer Scaling" in Chapter 2.
//  Notes:
*/

IPPAPI(IppStatus,ippsDeltaDeltaMul_Aurora_32f_D2,(const Ipp32f* pSrc, const Ipp32f* pVal,
                 Ipp32f* pDst, int dstStep, int height, int deltaMode))
IPPAPI(IppStatus,ippsDeltaDeltaMul_Aurora_16s_D2Sfs,(const Ipp16s* pSrc, const Ipp16s* pVal,
                 Ipp16s* pDst, int dstStep, int height, int deltaMode, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Model Evaluation
///////////////////////////////////////////////////////////////////////////// */

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsAddNRows_32f
//  Purpose:           Adds N vectors from the table
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    height           The number of rows in the pSrc.
//    offset
//    step             The row step in pSrc.
//    pInd             Pointer to the indexes vector [rows].
//    pAddInd          Pointer to the indexes addition vector [rows].
//    rows             The number of rows to add.
//    pDst             Pointer to the output vector [width].
//    width            The number of elements in the output vector pDst.
//    weight           The value to add to output vector elements.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pInd, pAddIndex, or
//                     pDst pointer is null.
//    ippStsSizeErr    Indicates an error when height, width, rows, or
//                     (pInd[i]+pAddIndex[i]) is less than 0;
//                     or (pInd[i]+pAddIndex[i]) >= height;
//                     or offset>segCount.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsAddNRows_32f_D2, (Ipp32f* pSrc, int height, int offset,
       int step, Ipp32s* pInd, Ipp16u* pAddInd, int rows, Ipp32f* pDst, int width,
       Ipp32f weight))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsScaleLM_*
//  Purpose:           Scales vector elements with thresholding.
//
//  Parameters:
//    pSrc             Pointer to the input vector [len].
//    pDst             Pointer to the output vector [len].
//    len              The number of elements in the pSrc and pDst vectors.
//    floor            A value used to limit each element of pSrc.
//    scale            The multiplier factor value.
//    base             The additive value.
//
//  Return:
//    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, ippsScaleLM_32f, (const Ipp32f *pSrc, Ipp32f *pDst,
       int len, Ipp32f floor, Ipp32f scale, Ipp32f base))

IPPAPI(IppStatus, ippsScaleLM_16s32s, (const Ipp16s* pSrc, Ipp32s* pDst,
       int len, Ipp16s floor, Ipp16s scale, Ipp32s base))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogAdd_*
//  Purpose:           Logarithmically adds two vectors in-place.
//  Parameters:
//    pSrc             The first input vector [len].
//    pDst             The second input and output vector [len].
//    len              The number of elements in the input and output vectors.
//    hint             Recommends to use a specific code for the
//                     Logarithmically adds.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pDst pointer is null.
//    ippStsSizeErr    Indicates an error when lenis less than or equal to 0.
//
*/
IPPAPI(IppStatus,ippsLogAdd_64f,(const Ipp64f* pSrc, Ipp64f* pSrcDst, int len,
       IppHintAlgorithm hint))

IPPAPI(IppStatus,ippsLogAdd_32f,(const Ipp32f* pSrc, Ipp32f* pSrcDst, int len,
       IppHintAlgorithm hint))

IPPAPI(IppStatus,ippsLogAdd_32s_Sfs,(const Ipp32s* pSrc, Ipp32s* pSrcDst, int len,
        int scaleFactor, IppHintAlgorithm hint))

IPPAPI(IppStatus,ippsLogAdd_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pSrcDst, int len,
        int scaleFactor, IppHintAlgorithm hint))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogSub_*
//  Purpose:           Logarithmically subtracts two vectors in place .
//  Parameters:
//    pSrc             Pointer to the input vector [len].
//    pDst             Pointer to the input and output vectors [len].
//    len              The number of elements in the input and output vectors.
//  Return:
//    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.
//    ippStsNoOperation Indicates an error when pDst[i] > pSrc[i]is more than 0.
*/
IPPAPI(IppStatus,ippsLogSub_32f,(const Ipp32f* pSrc, Ipp32f* pSrcDst, int len))

IPPAPI(IppStatus,ippsLogSub_64f,(const Ipp64f* pSrc, Ipp64f* pSrcDst, int len))

IPPAPI(IppStatus,ippsLogSub_32s_Sfs,(const Ipp32s* pSrc, Ipp32s* pSrcDst, int len,
        int scaleFactor))

IPPAPI(IppStatus,ippsLogSub_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pSrcDst, int len,
        int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMahDistSingle_*
//  Purpose:           Calculates the Mahalanobis distance
//                     for a single observation vector.
//  Parameters:
//    pSrc             Pointer to the input vector [len].
//    pMean            Pointer to the mean vector [len].
//    pVar             Pointer to the variance vector [len].
//    len              The number of elements in the input, mean,
//                     and variance vectors.
//    pResult          Pointer to the result value.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar, or
//                     pResult pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0
*/

IPPAPI(IppStatus, ippsMahDistSingle_32f, (const Ipp32f* pSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int len,
       Ipp32f* pResult))

IPPAPI(IppStatus, ippsMahDistSingle_64f, (const Ipp64f* pSrc,
       const Ipp64f* pMean, const Ipp64f* pVar, int len,
       Ipp64f* pResult))

IPPAPI(IppStatus, ippsMahDistSingle_32f64f,(const Ipp32f* pSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int len, Ipp64f* pResult))

IPPAPI(IppStatus, ippsMahDistSingle_16s32f,(const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int len, Ipp32f* pResult))

IPPAPI(IppStatus, ippsMahDistSingle_16s32s_Sfs,(const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int len, Ipp32s* pResult,
       int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMahDist_*_*
//  Purpose:           Calculates the Mahalanobis distances
//                     for multiple observation vectors.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    step             The row step in pSrc.
//    pMean            Pointer to the mean vector [width].
//    pVar             Pointer to the variance vector [width].
//    width            The length of the input matrix row, mean,
//                     and variance vectors.
//    pDst             Pointer to the result value [height].
//    height           The number of rows in the input matrix and the length of
//                     the result vector pDst.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pDst,o rmSrc pointer is null.
//    ippStsSizeErr    Indicates an error when width or heightis less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsMahDist_32f_D2, (const Ipp32f* pSrc, int step,
       const Ipp32f* pMean, const Ipp32f* pVar, int width, Ipp32f* pDst,
       int height))

IPPAPI(IppStatus, ippsMahDist_64f_D2, (const Ipp64f* pSrc, int step,
       const Ipp64f* pMean, const Ipp64f* pVar, int width, Ipp64f* pDst,
       int height))

IPPAPI(IppStatus, ippsMahDist_32f_D2L, (const Ipp32f** mSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int width, Ipp32f* pDst,
       int height))

IPPAPI(IppStatus, ippsMahDist_64f_D2L, (const Ipp64f** mSrc,
       const Ipp64f* pMean, const Ipp64f* pVar, int width, Ipp64f* pDst,
       int height))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMahDistMultiMix_*_*
//  Purpose:           Calculates the Mahalanobis distances
//                     for multiple means and variances
//  Parameters:
//    pMean            Pointer to the mean vector [height*step].
//    pVar             Pointer to the variance vector [height*step].
//    mMean            Pointer to the mean matrix [height][width].
//    mVar             Pointer to the variance matrix [height][width].
//    step             Row step in pSrc.
//    pSrc             Pointer to the input vector [width].
//    width            Length of the input matrix row and pSrc vector.
//    pDst             Pointer to the result vector [height].
//    height           Number of rows in input matrices and length of result
//                     vector pDst.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     mMean, mVar, or pDst pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsMahDistMultiMix_32f_D2, (const Ipp32f* pMean,
       const Ipp32f* pVar, int step, const Ipp32f* pSrc, int width,
       Ipp32f* pDst, int height))

IPPAPI(IppStatus, ippsMahDistMultiMix_64f_D2, (const Ipp64f* pMean,
       const Ipp64f* pVar, int step, const Ipp64f* pSrc, int width,
       Ipp64f* pDst, int height))

IPPAPI(IppStatus, ippsMahDistMultiMix_32f_D2L, (const Ipp32f** mMean,
       const Ipp32f** mVar, const Ipp32f* pSrc, int width, Ipp32f* pDst,
       int height))

IPPAPI(IppStatus, ippsMahDistMultiMix_64f_D2L, (const Ipp64f** mMean,
       const Ipp64f** mVar, const Ipp64f* pSrc, int width, Ipp64f* pDst,
       int height))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussSingle_*
//  Purpose:           Calculates the observation probability for a
//                     single Gaussian with an observation vector.
//
//  Parameters:
//    pSrc             Pointer to the input vector [len].
//    pMean            Pointer to the mean vector [len].
//    pVar             Pointer to the variance vector [len].
//    pBlockVar        Pointer to the block diagonal variance matrix.
//    len              Number of elements in the input, mean, and variance
//                     vectors.
//    pResult          Pointer to the result value.
//    val              Gaussian constant.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar, or
//                     pResult or pBlockVar pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0.
//
*/

/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/

IPPAPI(IppStatus, ippsLogGaussSingle_32f, (const Ipp32f* pSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int len,
       Ipp32f* pResult, Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussSingle_64f, (const Ipp64f* pSrc,
       const Ipp64f* pMean, const Ipp64f* pVar, int len,
       Ipp64f* pResult, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_32f64f, (const Ipp32f* pSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int len,
       Ipp64f* pResult, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_Scaled_16s32f, (const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32f* dst,
       Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussSingle_16s32s_Sfs, (const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32s* dst,
       Ipp32s val, int scaleFactor))


/*
//Case 2: Operation for the diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussSingle_DirectVar_32f,(const Ipp32f* pSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int len, Ipp32f* pResult,
       Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussSingle_DirectVar_64f,(const Ipp64f* pSrc,
       const Ipp64f* pMean, const Ipp64f* pVar, int len, Ipp64f* pResult,
       Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_DirectVar_32f64f,(const Ipp32f* pSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int len, Ipp64f* pResult,
       Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_DirectVarScaled_16s32f,(const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int len, Ipp32f* pResult,
       Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussSingle_DirectVar_16s32s_Sfs,(const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int len, Ipp32s* pResult,
       Ipp32s val, int scaleFactor))


/*
//Case 3: Operation for the identity covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussSingle_IdVar_32f,(const Ipp32f* pSrc,
       const Ipp32f* pMean, int len, Ipp32f* pResult, Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussSingle_IdVar_64f,(const Ipp64f* pSrc,
       const Ipp64f* pMean, int len, Ipp64f* pResult, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_IdVar_32f64f,(const Ipp32f* pSrc,
       const Ipp32f* pMean, int len, Ipp64f* pResult, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_IdVarScaled_16s32f,(const Ipp16s* pSrc,
       const Ipp16s* pMean, int len, Ipp32f* pResult, Ipp32f va,
       int scaleFactorl))

IPPAPI(IppStatus, ippsLogGaussSingle_IdVar_16s32s_Sfs,(const Ipp16s* pSrc,
       const Ipp16s* pMean, int len, Ipp32s* pResult, Ipp32s val,
       int scaleFactor))


/*
//Case 4: Operation for the block diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussSingle_BlockDVar_32f,(const Ipp32f* pSrc,
       const Ipp32f* pMean,const IppsBlockDMatrix_32f* pVar, int len,
       Ipp32f* pResult, Ipp32f val))
IPPAPI(IppStatus, ippsLogGaussSingle_BlockDVar_64f,(const Ipp64f* pSrc,
       const Ipp64f* pMean, const IppsBlockDMatrix_64f * pVar, int len,
       Ipp64f* pResult, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_BlockDVar_32f64f,(const Ipp32f* pSrc,
       const Ipp32f* pMean, const IppsBlockDMatrix_32f * pVar, int len,
       Ipp64f* pResult, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussSingle_BlockDVarScaled_16s32f,(const Ipp16s* pSrc,
       const Ipp16s* pSrcMean,const IppsBlockDMatrix_16s* pSrcVar, int srcLen,Ipp32f* pResult,
       Ipp32f val,int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussSingle_BlockDVar_16s32s_Sfs,(const Ipp16s* pSrc,
       const Ipp16s* pMean, const IppsBlockDMatrix_16s * pVar, int len,
       Ipp32s* pResult, Ipp32s val, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGauss_*
//  Purpose:           Calculates the observation probability for a single
//                     Gaussian with multiple observation vectors.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    step             The row step in pSrc.
//    pMean            Pointer to the mean vector [width].
//    pVar             Pointer to the variance vector [width].
//    width            Length of the mean and variance vectors.
//    pDst             Pointer to the result value [height].
//    pSrcDst          Pointer to the input and output vector [height].
//    height           The number of rows in the input matrix and the length of
//                     the result vector pDst.
//    val              Gaussian constant.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pDst,or mSrc pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/

/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGauss_16s32s_D2Sfs, (const Ipp16s* pSrc, int step,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32s* pDst,
       int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_16s32s_D2LSfs, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32s* pDst,
       int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_32f_D2, (const Ipp32f* pSrc, int step,
       const Ipp32f* pMean, const Ipp32f* pVar, int width, Ipp32f* pDst,
       int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGauss_64f_D2, (const Ipp64f* pSrc, int step,
       const Ipp64f* pMean, const Ipp64f* pVar, int width, Ipp64f* pDst,
       int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGauss_32f_D2L, (const Ipp32f** mSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int width,
       Ipp32f* pDst, int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGauss_64f_D2L, (const Ipp64f** mSrc,
       const Ipp64f* pMean, const Ipp64f* pVar, int width,
       Ipp64f* pDst, int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGauss_Scaled_16s32f_D2, (const Ipp16s* pSrc, int step,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32f* pDst,
       int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_Scaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32f* pDst,
       int height, Ipp32f val, int scaleFactor))


/*
//Case 2: Operation for the identity covariance matrix
*/

IPPAPI(IppStatus, ippsLogGauss_IdVar_16s32s_D2Sfs,(const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32s* pDst, int height,
       Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_IdVarScaled_16s32f_D2,(const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32f* pDst, int height,
       Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_IdVar_32f_D2,(const Ipp32f* pSrc, int step,
       const Ipp32f* pMean, int width, Ipp32f* pDst, int height,
       Ipp32f val))

IPPAPI(IppStatus, ippsLogGauss_IdVar_64f_D2,(const Ipp64f* pSrc, int step,
       const Ipp64f* pMean, int width, Ipp64f* pDst, int height,
       Ipp64f val))

IPPAPI(IppStatus, ippsLogGauss_IdVar_16s32s_D2LSfs,(const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32s* pDst, int height, Ipp32s val,
       int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_IdVarScaled_16s32f_D2L,(const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32f* pDst, int height, Ipp32f val,
       int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_IdVar_32f_D2L,(const Ipp32f** mSrc,
       const Ipp32f* pMean, int width, Ipp32f* pDst, int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGauss_IdVar_64f_D2L,(const Ipp64f** mSrc,
       const Ipp64f* pMean, int width, Ipp64f* pDst, int height, Ipp64f val))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussMultiMix_*
//  Purpose:           Calculates the observation probability for
//                     multiple Gaussian mixture components.
//
//  Parameters:
//    pMean            Pointer to the mean vector [height*step].
//    pVar             Pointer to the variance vector [height*step].
//    mMean            Pointer to the mean matrix [height][width].
//    mVar             Pointer to the variance matrix [height][width].
//    pSrcDst          Pointer to the input additive values and
//                     the result vector [height].
//    step             The row step in pMean.
//    pSrc             Pointer to the input vector [width].
//    height           The number of rows in input matrices and the length of
//                     the result vector pSrcDst.
//    width            The length of the input matrices row and the vector pSrc.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst, mMean, or mVar pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsLogGaussMultiMix_16s32s_D2Sfs, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
       Ipp32s* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMultiMix_16s32s_D2LSfs, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, Ipp32s* pSrcDst,
       int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMultiMix_Scaled_16s32f_D2, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
       Ipp32f* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMultiMix_Scaled_16s32f_D2L, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, Ipp32f* pSrcDst,
       int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMultiMix_32f_D2, (const Ipp32f* pMean,
       const Ipp32f* pVar, int step, const Ipp32f* pSrc, int width,
       Ipp32f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussMultiMix_64f_D2, (const Ipp64f* pMean,
       const Ipp64f* pVar, int step, const Ipp64f* pSrc, int width,
       Ipp64f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussMultiMix_32f_D2L, (const Ipp32f** mMean,
       const Ipp32f** mVar, const Ipp32f* pSrc, int width, Ipp32f* pSrcDst,
       int height))

IPPAPI(IppStatus, ippsLogGaussMultiMix_64f_D2L, (const Ipp64f** mMean,
       const Ipp64f** mVar, const Ipp64f* pSrc, int width, Ipp64f* pSrcDst,
       int height))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussMax_*_D2
//  Purpose:           Computes maximum  value of a vector dst and
//                     logarithms of the Gaussian probability distribution function.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    step             The row step in pSrc.
//    pMean            Pointer to the mean vector [width].
//    pVar             Pointer to the variance vector [width].
//    width            The length of the input matrix row, mean,
//                     and variance vectors.
//    pSrcDst          Pointer to the input and output vector [height].
//    height           The number of rows in the input matrix and the length of
//                     the result vector pSrcDst.
//    val              The value to add to each distance.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst, mSrc pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/

/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussMax_32f_D2, (const Ipp32f* pSrc, int step,
      const Ipp32f* pMean, const Ipp32f* pVar, int width,
      Ipp32f* pSrcDst, int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussMax_32f_D2L, (const Ipp32f** mSrc,
      const Ipp32f* pMean, const Ipp32f*  pVar, int width, Ipp32f* pSrcDst,
      int height, Ipp32f  val))

IPPAPI(IppStatus, ippsLogGaussMax_64f_D2, (const Ipp64f* pSrc, int step,
      const Ipp64f* pMean, const Ipp64f* pVar, int width, Ipp64f* pSrcDst,
      int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussMax_64f_D2L, (const Ipp64f** mSrc,
      const Ipp64f* pMean, const Ipp64f* pVar, int width, Ipp64f* pSrcDst,
      int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussMax_16s32s_D2Sfs, (const Ipp16s* pSrc,
      int step, const Ipp16s* pMean, const Ipp16s* pVar, int width,
      Ipp32s* pSrcDst, int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_16s32s_D2LSfs, (const Ipp16s** mSrc,
      const Ipp16s* pMean, const Ipp16s*  pVar, int width, Ipp32s* pSrcDst,
      int height, Ipp32s  val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_Scaled_16s32f_D2, (const Ipp16s* pSrc, int step,
      const Ipp16s* pMean, const Ipp16s* pVar, int width,
      Ipp32f* pSrcDst, int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_Scaled_16s32f_D2L, (const Ipp16s** mSrc,
      const Ipp16s* pMean, const Ipp16s*  pVar, int width, Ipp32f* pSrcDst,
      int height, Ipp32f  val, int scaleFactor))


/*
//Case 2: Operation for the identity covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussMax_IdVar_32f_D2, (const Ipp32f* pSrc,
       int step, const Ipp32f* pMean, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussMax_IdVar_32f_D2L, (const Ipp32f** mSrc,
       const Ipp32f* pMean, int width, Ipp32f* pSrcDst, int height,
       Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussMax_IdVar_64f_D2, (const Ipp64f* pSrc,
       int step, const Ipp64f* pMean, int width, Ipp64f* pSrcDst,
       int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussMax_IdVar_64f_D2L, (const Ipp64f** mSrc,
       const Ipp64f* pMean, int width, Ipp64f* pSrcDst, int height,
       Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussMax_IdVar_16s32s_D2Sfs, (const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32s* pSrcDst,
       int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_IdVar_16s32s_D2LSfs, (const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32s* pSrcDst, int height,
       Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_IdVarScaled_16s32f_D2, (const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_IdVarScaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32f* pSrcDst, int height,
       Ipp32f val, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussMaxMultiMix_*_*
//  Purpose:           Computes the maximum of the Gaussian probability
//                     distribution function.
//  Parameters:
//    pMean            Pointer to the mean vector [height*step].
//    pVar             Pointer to the variance vector [height*step].
//    mMean            Pointer to the mean matrix [height][width].
//    mVar             Pointer to the variance matrix [height][width].
//    pVal             Pointer to the input vector of Max values [height].
//    pSrcDst          Pointer to the input and output vector [height].
//    step             Row step in pMean and pVar.
//    pSrc             Pointer to theinput vector [width].
//    height           Number of rows in input matrices and the length of
//                     the result vector pSrcDst.
//    width            Length of the input matrices row and the vector pSrc.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst, mMean, mVar or pVal pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_32f_D2, (const Ipp32f* pMean,
       const Ipp32f* pVar, int step, const Ipp32f* pSrc, int width,
       const Ipp32f* pVal, Ipp32f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_32f_D2L, (const Ipp32f** mMean,
       const Ipp32f** mVar, const Ipp32f* pSrc, int width, const Ipp32f* pVal,
       Ipp32f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_64f_D2, (const Ipp64f* pMean,
       const Ipp64f* pVar, int step, const Ipp64f* pSrc, int width,
       const Ipp64f* pVal, Ipp64f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_64f_D2L, (const Ipp64f** mMean,
       const Ipp64f** mVar, const Ipp64f* pSrc, int width, const Ipp64f* pVal,
       Ipp64f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_Scaled_16s32f_D2, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
       const Ipp32f* pVal, Ipp32f* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_Scaled_16s32f_D2L, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, const Ipp32f* pVal,
       Ipp32f* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_16s32s_D2Sfs, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
       const Ipp32s* pVal, Ipp32s* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_16s32s_D2LSfs, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, const Ipp32s* pVal,
       Ipp32s* pSrcDst, int height, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussAdd_32f_D2
//  Purpose:           Calculates the likelihood probability for multiple
//                     observation vectors.
//
//  Parameters:
//    pSrc             Pointer to the input vector [width*height]
//    mSrc             Pointer to the input matrix [height][width].
//    step             Row step in pSrc.
//    pMean            Pointer to the mean vector [width]
//    pVar             Pointer to the variance vector [width]
//    width            Length of the mean, and variance vectors.
//    pSrcDst          Pointer to input vector and output vector [height]
//    height           Length of  the input and output vector pSrcDst
//    val              Value to add to each distance.
//
//  Returns:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst or mSrc pointer is null.
//    ippStsSizeErr    Indicates an error when width or height
//                     is less than or equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
*/

/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussAdd_32f_D2, (const Ipp32f* pSrc, int step,
       const Ipp32f* pMean, const Ipp32f* pVar, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussAdd_32f_D2L, (const Ipp32f** mSrc,
       const Ipp32f* pMean, const Ipp32f* pVar, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussAdd_64f_D2,(const Ipp64f* pSrc, int step,
       const Ipp64f* pMean, const Ipp64f* pVar, int width,
       Ipp64f* pSrcDst, int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussAdd_64f_D2L, (const Ipp64f** mSrc, const Ipp64f* pMean,
       const Ipp64f* pVar, int width, Ipp64f* pSrcDst, int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussAdd_Scaled_16s32f_D2,(const Ipp16s* pSrc, int step,
       const Ipp16s* pMean, const Ipp16s* pVar, int width,
       Ipp32f* pSrcDst, int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAdd_Scaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val, int scaleFactor))

/*
//Case 2: Operation for the identity covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussAdd_IdVarScaled_16s32f_D2,(const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAdd_IdVarScaled_16s32f_D2L,(const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32f* pSrcDst, int height, Ipp32f val,
       int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAdd_IdVar_32f_D2,(const Ipp32f* pSrc,
       int step, const Ipp32f* pMean, int width, Ipp32f* pSrcDst, int height,
       Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussAdd_IdVar_32f_D2L,(const Ipp32f** mSrc,
       const Ipp32f* pMean, int width, Ipp32f* pSrcDst, int height, Ipp32f val))

IPPAPI(IppStatus, ippsLogGaussAdd_IdVar_64f_D2,(const Ipp64f* pSrc, int step,
       const Ipp64f* pMean, int width, Ipp64f* pSrcDst, int height, Ipp64f val))

IPPAPI(IppStatus, ippsLogGaussAdd_IdVar_64f_D2L,(const Ipp64f** mSrc,
       const Ipp64f* pMean, int width, Ipp64f* pSrcDst, int height, Ipp64f val))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussAddMultiMix_*_*
//  Purpose:           Calculates the likelihood probability for multiple
//                     Gaussian mixture components.
//
//  Parameters:
//    pMean            Pointer to the variance vector [height*step].
//    mMean            Pointer to the mean matrix [height][width].
//    pVar             Pointer to the variance vector [height*step].
//    mVar             Pointer to the variance matrix [height][width].
//    pVal             Pointer to the input vector of additive values [height].
//    pSrcDst          Pointer to the input and output vector [height].
//    step             The row step in pMean.
//    pSrc             Pointer to the input vector [width].
//    height           The number of rows in input matrices and the length of
//                     the result vector pSrcDst.
//    width            The length of the input matrices row and the vector pSrc.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst, mMean, mVar or pVal pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/

IPPAPI(IppStatus, ippsLogGaussAddMultiMix_Scaled_16s32f_D2, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
        const Ipp32f* pVal, Ipp32f* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAddMultiMix_Scaled_16s32f_D2L, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, const Ipp32f* pVal,
       Ipp32f* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAddMultiMix_32f_D2, (const Ipp32f* pMean,
       const Ipp32f* pVar, int step, const Ipp32f* pSrc, int width,
       const Ipp32f* pVal, Ipp32f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussAddMultiMix_32f_D2L, (const Ipp32f** mMean,
       const Ipp32f** mVar, const Ipp32f* pSrc, int width, const Ipp32f* pVal,
       Ipp32f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussAddMultiMix_64f_D2, (const Ipp64f* pMean,
       const Ipp64f* pVar, int step, const Ipp64f* pSrc, int width,
       const Ipp64f* pVal, Ipp64f* pSrcDst, int height))

IPPAPI(IppStatus, ippsLogGaussAddMultiMix_64f_D2L, (const Ipp64f** mMean,
       const Ipp64f** mVar, const Ipp64f* pSrc, int width,  const Ipp64f* pVal,
       Ipp64f* pSrcDst, int height))


/* /////////////////////////////////////////////////////////////////////////////
//  Model Estimation
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMeanColumn_*
//  Purpose:           Computes the mean values vector of column
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    height           The number rows in the input matrix.
//    step             The row step in pSrc.
//    pDstMean         Pointer to the output mean vector [width].
//    width            The number of columns in the input matrix and the length
//                     of the output mean vector pDstMean.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, mSrc, or pDstMean
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than
//                     or equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsMeanColumn_16s_D2,(const Ipp16s* pSrc, int height,
       int step, Ipp16s* pDstMean, int width))

IPPAPI(IppStatus, ippsMeanColumn_16s_D2L,(const Ipp16s** mSrc, int height,
       Ipp16s* pDstMean, int width))


IPPAPI(IppStatus, ippsMeanColumn_32f_D2,(const Ipp32f* pSrc, int height,
       int step, Ipp32f* pDstMean, int width))

IPPAPI(IppStatus, ippsMeanColumn_32f_D2L,(const Ipp32f** mSrc, int height,
       Ipp32f* pDstMean, int width))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsVarColumn_*
//  Purpose:           Computes the variance values vector of column elements.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    height           The number of rows in the input matrix.
//    step             The row step in pSrc.
//    pSrcMean         Pointer to the input mean vector [width].
//    pDstVar          Pointer to the output variance vector of length [width].
//    width            Number of columns in the input matrix and the length of
//                     the input mean vector pSrcMean and output variance
//                     vector pDstVar.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrc, pSrcMean, pDstVar, or
//                     pSrc pointer is null.
//    ippStsSizeErr    Indicates an error when srcHight or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/

IPPAPI(IppStatus, ippsVarColumn_16s_D2Sfs,(const Ipp16s* pSrc, int height,
       int step, Ipp16s* pSrcMean, Ipp16s* pDstVar, int width, int scaleFactor))

IPPAPI(IppStatus, ippsVarColumn_16s_D2LSfs,(const Ipp16s** mSrc, int height,
       Ipp16s* pSrcMean, Ipp16s* pDstVar, int width, int scaleFactor))

IPPAPI(IppStatus, ippsVarColumn_32f_D2,(const Ipp32f* pSrc, int height,
       int step, Ipp32f* pSrcMean, Ipp32f* pDstVar, int width))

IPPAPI(IppStatus, ippsVarColumn_32f_D2L,(const Ipp32f** mSrc, int height,
       Ipp32f* pSrcMean, Ipp32f* pDstVar, int width))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMeanVarColumn_*
//  Purpose:           Computes the mean and variance values vector of
//                     column elements.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][width].
//    height           The number of rows in the input matrix.
//    step             The row step in pSrc.
//    pDstMean         Pointer to the output mean vector [width].
//    pDstVar          Pointer to the output variance vector [width].
//    width            The number of columns in the input matrix and the length
//                     of the output mean vector pDstMean and
//                     variance vector pDstVar.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, mSrc, pDstMean, or
//                     pDstVar pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than
//                     or equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsMeanVarColumn_16s_D2Sfs,(const Ipp16s* pSrc, int height,
       int step, Ipp16s* pDstMean, Ipp16s* pDstVar, int width, int scaleFactor))

IPPAPI(IppStatus, ippsMeanVarColumn_16s_D2LSfs,(const Ipp16s** mSrc, int height,
       Ipp16s* pDstMean, Ipp16s* pDstVar, int width, int scaleFactor))

IPPAPI(IppStatus, ippsMeanVarColumn_16s16s32s_D2,(const Ipp16s* pSrc, int height,
       int step, Ipp16s* pDstMean, Ipp32s* pDstVar, int width))

IPPAPI(IppStatus, ippsMeanVarColumn_16s16s32s_D2L,(const Ipp16s** mSrc, int height,
       Ipp16s* pDstMean, Ipp32s* pDstVar, int width))

IPPAPI(IppStatus, ippsMeanVarColumn_16s32s_D2Sfs,(const Ipp16s* pSrc, int height,
       int step, Ipp32s* pDstMean, Ipp32s* pDstVar, int width, int scaleFactor))

IPPAPI(IppStatus, ippsMeanVarColumn_16s32s_D2LSfs,(const Ipp16s** mSrc, int height,
       Ipp32s* pDstMean, Ipp32s* pDstVar, int width, int scaleFactor))

IPPAPI(IppStatus, ippsMeanVarColumn_32f_D2,(const Ipp32f* pSrc, int height,
       int step, Ipp32f* pDstMean, Ipp32f* pDstVar, int width))

IPPAPI(IppStatus, ippsMeanVarColumn_32f_D2L,(const Ipp32f** mSrc, int height,
       Ipp32f* pDstMean, Ipp32f* pDstVar, int width))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsNormalizeColumn_*_*
//  Purpose:           Normalizes the matrix rows with the help of mean
//                     and variance vectors.
//  Parameters:
//    pMean              Pointer to the mean vector [width].
//    pVar               Pointer to the variance vector [width].
//    pSrcDst            Pointer to the input and output vector [height*step].
//    mSrcDst            Pointer to the input/output matrix [height][width]
//    width              The number of elements in the mean
//                       and variance vectors.
//    step               The row step in pSrcDst.
//    height             The number of rows in the input and output matrix
//    scaleFactor
//
//  Return:
//    ippStsNoErr        Indicates no error.
//    ippStsNullPtrErr   Indicates an error when the pMean, pVar, or pSrcDst
//                       or mSrcDst pointer is null.
//    ippStsSizeErr      Indicates an error when height or width is less than or
//                       equal to 0.
//    ippStsStrideErr    Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsNormalizeColumn_32f_D2,(Ipp32f* pSrcDst, int step,
       int height, const Ipp32f* pMean, const Ipp32f* pVar, int width))

IPPAPI(IppStatus, ippsNormalizeColumn_32f_D2L,(Ipp32f** mSrcDst, int height,
       const Ipp32f* pMean, const Ipp32f* pVar, int width))

IPPAPI(IppStatus, ippsNormalizeColumn_16s_D2Sfs,(Ipp16s* pSrcDst, int step,
       int height, const Ipp16s* pMean, const Ipp16s* pVar, int width,
       int scaleFactor))

IPPAPI(IppStatus, ippsNormalizeColumn_16s_D2LSfs,(Ipp16s** mSrcDst, int height,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsNormalizeInRange_*
//
//  Purpose:      Normalizes and scales input vector elements.
//
//  Parameters:
//    pSrc        Pointer to the input array [len].
//    pSrcDst     Pointer to the input and output array
//                (for the in-place operation) [len].
//    pDst        Pointer to the output array [len].
//    len         Number of elements in the input and output array.
//    lowCut      Lower cutoff value.
//    highCut     High cutoff value.
//    range       Upper bound of output data value (lower bound is 0).
//
//  Return:
//    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.
//    ippStsBadArgErr   Indicates an error when 0<=lowCut<highCut<=1 condition
//                      is not true or range is less than 0.
//    ippStsInvZero     Indicates a warning when  Xmin = Xmax. All elements of
//                      the output vector are set to 0.
*/
IPPAPI(IppStatus, ippsNormalizeInRange_16s8u, (const Ipp16s* pSrc, Ipp8u* pDst,
       int len, Ipp32f lowCut, Ipp32f highCut, Ipp8u range))

IPPAPI(IppStatus, ippsNormalizeInRange_16s, (const Ipp16s* pSrc, Ipp16s* pDst,
       int len, Ipp32f lowCut, Ipp32f highCut, Ipp16s range))

IPPAPI(IppStatus, ippsNormalizeInRange_16s_I, (Ipp16s* pSrcDst,
       int len, Ipp32f lowCut, Ipp32f highCut, Ipp16s range))

IPPAPI(IppStatus, ippsNormalizeInRange_32f8u, (const Ipp32f* pSrc, Ipp8u* pDst,
       int len, Ipp32f lowCut, Ipp32f highCut, Ipp8u range))

IPPAPI(IppStatus, ippsNormalizeInRange_32f16s, (const Ipp32f* pSrc, Ipp16s* pDst,
       int len, Ipp32f lowCut, Ipp32f highCut, Ipp16s range))

IPPAPI(IppStatus, ippsNormalizeInRange_32f, (const Ipp32f* pSrc, Ipp32f* pDst,
       int len, Ipp32f lowCut, Ipp32f highCut, Ipp32f range))

IPPAPI(IppStatus, ippsNormalizeInRange_32f_I, (Ipp32f* pSrcDst,
       int len, Ipp32f lowCut, Ipp32f highCut, Ipp32f range))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsNormalizeInRangeMinMax_*
//
//  Purpose:      Normalizes and scales input vector elements.
//
//  Parameters:
//    pSrc        Pointer to the input array [len].
//    pSrcDst     Pointer to the input and output array
//                (for the in-place operation) [len].
//    pDst        Pointer to the output array [len].
//    len         Number of elements in the input and output array.
//    lowCut      Lower cutoff value.
//    highCut     High cutoff value.
//    range       Upper bound of output data value (lower bound is 0).
//    valMin      Minimum of input data.
//    valMax      Maximum of input data.
//
//  Return:
//    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.
//    ippStsBadArgErr   Indicates an error when 0<=lowCut<highCut<=1 condition
//                      is not true or range is less than 0 or valMin is greater
//                      than valMax.
//    ippStsInvZero     Indicates a warning when  valMin=valMax. All elements of
//                      the output vector are set to 0.
*/
IPPAPI(IppStatus, ippsNormalizeInRangeMinMax_16s8u, (const Ipp16s* pSrc, Ipp8u* pDst,
       int len, Ipp16s valMin, Ipp16s valMax,
       Ipp32f lowCut, Ipp32f highCut, Ipp8u range))

IPPAPI(IppStatus, ippsNormalizeInRangeMinMax_16s, (const Ipp16s* pSrc, Ipp16s* pDst,
       int len, Ipp16s valMin, Ipp16s valMax,
       Ipp32f lowCut, Ipp32f highCut, Ipp16s range))

IPPAPI(IppStatus, ippsNormalizeInRangeMinMax_16s_I, (Ipp16s* pSrcDst,
       int len, Ipp16s valMin, Ipp16s valMax, Ipp32f
       lowCut, Ipp32f highCut, Ipp16s range))

IPPAPI(IppStatus, ippsNormalizeInRangeMinMax_32f8u, (const Ipp32f* pSrc, Ipp8u* pDst,
       int len, Ipp32f valMin, Ipp32f valMax,
       Ipp32f lowCut, Ipp32f highCut, Ipp8u range))

IPPAPI(IppStatus, ippsNormalizeInRangeMinMax_32f16s, (const Ipp32f* pSrc, Ipp16s* pDst,
       int len, Ipp32f valMin, Ipp32f valMax,
       Ipp32f lowCut, Ipp32f highCut, Ipp16s range))

IPPAPI(IppStatus, ippsNormalizeInRangeMinMax_32f, (const Ipp32f* pSrc, Ipp32f* pDst,
       int len, Ipp32f valMin, Ipp32f valMax,
       Ipp32f lowCut, Ipp32f highCut, Ipp32f range))

IPPAPI(IppStatus, ippsNormalizeInRangeMinMax_32f_I, (Ipp32f* pSrcDst,
       int len, Ipp32f valMin, Ipp32f valMax,
       Ipp32f lowCut, Ipp32f highCut, Ipp32f range))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMeanVarAcc_*
//  Purpose:           Computes mean and variance accumulators.
//  Parameters:
//    pSrc             Pointer to the input vector [len].
//    pSrcMean         Pointer to the mean vector [len].
//    pDstMeanAcc      Pointer to the mean accumulated vector [len].
//    pDstVarAcc       Pointer to the variance accumulated vector [len].
//    len              The number of elements in the input, mean,
//                     and variance vectors.
//    val              The value of the multiplyed mean and variance vectors
//                     before accumulated.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pSrcMean, pDstMeanAcc,
//                     or pDstVarAcc pointer is null.
//    ippStsSizeErr    Indicates an error when lenis less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsMeanVarAcc_32f, (Ipp32f const* pSrc,
       Ipp32f const* pSrcMean, Ipp32f* pDstMeanAcc, Ipp32f* pDstVarAcc,
       int len, Ipp32f val))

IPPAPI(IppStatus, ippsMeanVarAcc_64f, (Ipp64f const* pSrc,
       Ipp64f const* pSrcMean, Ipp64f* pDstMeanAcc, Ipp64f* pDstVarAcc,
       int len, Ipp64f val))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsGaussianDist_32f
//  Purpose:           Computes distance between Gaussians.
//  Parameters:
//    pSrcMean1        Pointer to the mean vector of the first Gaussian [len]
//    pSrcVar1         Pointer to the variance vector of the
//                     first Gaussian [len].
//    pSrcMean2        Pointer to the mean vector of the second
//                     Gaussian [len].
//    pSrcVar2         Pointer to the variance vector of the second
//                     Gaussian [len].
//    len              The number of elements in the mean and variance vectors.
//    pResult          Pointer to the distance value.
//    wgt1             The first Gaussian weight.
//    det1             The first Gaussian determinant.
//    wgt2             The second Gaussian weight.
//    det2             The second Gaussian determinant.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcMean1, pSrcMean2,
//                     pSrcVar1, pSrcVar2, or pResult pointer is null.
//    ippStsSizeErr    Indicates an error when lenis less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsGaussianDist_32f,(const Ipp32f* pSrcMean1,
       const Ipp32f* pSrcVar1, const Ipp32f* pSrcMean2, const Ipp32f* pSrcVar2,
       int len, Ipp32f* pResult, Ipp32f wgt1, Ipp32f det1, Ipp32f wgt2,
       Ipp32f det2))

IPPAPI(IppStatus, ippsGaussianDist_64f,(const Ipp64f* pSrcMean1,
       const Ipp64f* pSrcVar1, const Ipp64f* pSrcMean2, const Ipp64f* pSrcVar2,
       int len, Ipp64f* pResult, Ipp64f wgt1, Ipp64f det1, Ipp64f wgt2,
       Ipp64f det2))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsGaussianSplit_32f
//  Purpose:           Splits simple Gaussian probability distribution functions
//
//  Parameters:
//    pSrcMean1        Pointer to the input and the first output mean
//                     vector [len].
//    pSrcVar1         Pointer to the input and the first variance vector [len].
//    pSrcMean2        Pointer to the second output mean vector [len].
//    pSrcVar2         Pointer to the input and the second variance vector [len].
//    len              The number of elements in the mean and variance vectors.
//    val              The variance perturbation value.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcMean1, pSrcMean2,
//                     pSrcVar1, or pSrcVar2 pointer is null.
//    ippStsSizeErr    Indicates an error when lenis less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsGaussianSplit_32f,(Ipp32f* pSrcMean1, Ipp32f* pSrcVar1,
       Ipp32f* pSrcMean2, Ipp32f* pSrcVar2, int len, Ipp32f val))

IPPAPI(IppStatus, ippsGaussianSplit_64f,(Ipp64f* pSrcMean1,  Ipp64f* pSrcVar1,
       Ipp64f* pSrcMean2, Ipp64f* pSrcVar2, int len, Ipp64f val))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsGaussianMerge_32f
//  Purpose:           Merges two simple Gaussian probability
//                     distribution functions.
//  Parameters:
//    pSrcMean1        Pointer to the mean vector of the first Gaussian [len].
//    pSrcVar1         Pointer to the variance vector of the first
//                     Gaussian [len].
//    pSrcMean2        Pointer to the mean vector of the second Gaussian [len].
//    pSrcVar2         Pointer to the variance vector of the second
//                     Gaussian [len].
//    pDstMean         Pointer to the mean vector of the merged Gaussian [len].
//    pDstVar          Pointer to the variance vector of the merged
//                     Gaussian [len].
//    len              The number of elements in the mean and variance vectors.
//    pDstDet          Pointer to the determinant of the merged Gaussian.
//    wgt1             The first Gaussian weight.
//    wgt2             The second Gaussian weight.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcMean1, pSrcMean2,
//                     pSrcVar1, pSrcVar2, pDstMean, pDstVar, or pDstDet
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when lenis less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsGaussianMerge_32f,(const Ipp32f* pSrcMean1,
       const Ipp32f* pSrcVar1, const Ipp32f* pSrcMean2, const Ipp32f* pSrcVar2,
       Ipp32f* pDstMean, Ipp32f* pDstVar, int len, Ipp32f* pDstDet, Ipp32f wgt1,
       Ipp32f wgt2))

IPPAPI(IppStatus, ippsGaussianMerge_64f,(const Ipp64f* pSrcMean1,
       const  Ipp64f* pSrcVar1, const Ipp64f* pSrcMean2, const Ipp64f* pSrcVar2,
       Ipp64f* pDstMean, Ipp64f* pDstVar, int len, Ipp64f* pDstDet, Ipp64f wgt1,
       Ipp64f wgt2))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsEntropy_*
//
//  Purpose:      Calculate exponent of minus squared argument.
//
//  Parameters:
//    pSrc        Pointer to the input vector [len].
//    pResult     Pointer to the destination enropy value.
//    len         Length of the input vector.
//    srcShiftVal
//    scaleFactor
//
//  Return:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr  Indicates an error when the pSrc or pResult pointer is null.
//    ippStsSizeErr     Indicates an error when len is less than or equal to 0.
//    ippStsLnNegArg    Indicates a warning for input vector elements less than 0.
//                      Operation execution is aborted. The destination
//                      value NaN and for integer operations is 0.
//
*/
IPPAPI(IppStatus, ippsEntropy_32f, (const Ipp32f* pSrc, int len, Ipp32f* pResult))

IPPAPI(IppStatus, ippsEntropy_16s32s_Sfs, (const Ipp16s* pSrc, int srcShiftVal,
       int len, Ipp32s* pResult, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsSinC_*
//
//  Purpose:      Calculate sine divided by argument.
//
//  Parameters:
//    pSrc        Pointer to the input array [len].
//    pSrcDst     Pointer to the input and destination vector [len].
//    pDst        Pointer to the output array [len].
//    len         Number of elements in the input vector.
//
//  Return:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr  Indicates an error when the pSrc, pSrcDst or pDst
//                      pointer is null.
//    ippStsSizeErr     Indicates an error when len is less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsSinC_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsSinC_32f64f, (const Ipp32f* pSrc, Ipp64f* pDst, int len))

IPPAPI(IppStatus, ippsSinC_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))

IPPAPI(IppStatus, ippsSinC_32f_I, (Ipp32f* pSrcDst, int len))

IPPAPI(IppStatus, ippsSinC_64f_I, (Ipp64f* pSrcDst, int len))

/* /////////////////////////////////////////////////////////////////////////////
// Name:          ippsExpNegSqr_*
//
// Purpose:       Calculate exponent of minus squared argument.
//
// Parameters:
//    pSrc        Pointer to the input array [len].
//    pSrcDst     Pointer to the input and destination vector [len].
//    pDst        Pointer to the destination vector [len].
//    len         Length of the input and output vectors.
//
// Return:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr  Indicates an error when the pSrc, pSrcDst or pDst
//                      pointer is null.
//    ippStsSizeErr     Indicates an error when len is less than or equal to 0.
//
// File:    psexpns.c
*/
IPPAPI(IppStatus, ippsExpNegSqr_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsExpNegSqr_32f64f,(const Ipp32f* pSrc, Ipp64f* pDst, int len))

IPPAPI(IppStatus, ippsExpNegSqr_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))

IPPAPI(IppStatus, ippsExpNegSqr_32f_I, (Ipp32f* pSrcDst, int len))

IPPAPI(IppStatus, ippsExpNegSqr_64f_I, (Ipp64f* pSrcDst, int len))


/*///////////////////////////////////////////////////////////////////////////////
//  Name:              IppStatus ippsBhatDistSLog_*
//  Purpose:           Calculates the Bhattacharia distance between two Gaussians.
//
//  Parameters:
//    pSrcMean1        Pointer to the first mean vector [len].
//    pSrcVar1         Pointer to the first variance vector [len].
//    pSrcMean2        Pointer to the second mean vector [len].
//    pSrcVar2         Pointer to the second variance vector [len].
//    pResult          Pointer to the result value.
//    len              Length of the input mean and variance vectors.
//    sumLog1          Sum of the first Gaussian variance in the logarithmic
//                     representation.
//    sumLog2          Sum of the second Gaussian variance in the logarithmic
//                     representation.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates  an error when the pSrcMean1, pSrcVar1,
//                     pSrcMean2, pSrcVar2 or pResult pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0
//    ippStsLnZeroArg  Indicates a warning that a zero value was detected in
//                     the input vector. The execution is not aborted.
//                     The result value is set to -Inf if there is no negative
//                     element in the vector.
//    ippStsLnNegArg   Indicates a warning that negative values were detected
//                     in the input vector. The execution is not aborted.
//                     The result value is set to NaN.
//
*/

IPPAPI(IppStatus, ippsBhatDist_32f,(const Ipp32f* pSrcMean1,
       const Ipp32f* pSrcVar1, const Ipp32f* pSrcMean2, const Ipp32f* pSrcVar2,
       int len, Ipp32f* pResult))

IPPAPI(IppStatus, ippsBhatDist_32f64f,(const Ipp32f* pSrcMean1,
       const Ipp32f* pSrcVar1, const Ipp32f* pSrcMean2, const Ipp32f* pSrcVar2,
       int len, Ipp64f* pResult))

IPPAPI(IppStatus, ippsBhatDistSLog_32f,(const Ipp32f* pSrcMean1,
       const Ipp32f* pSrcVar1, const Ipp32f* pSrcMean2, const Ipp32f* pSrcVar2,
       int len, Ipp32f* pResult, Ipp32f sumLog1, Ipp32f sumLog2))

IPPAPI(IppStatus, ippsBhatDistSLog_32f64f,(const Ipp32f* pSrcMean1,
       const Ipp32f* pSrcVar1, const Ipp32f* pSrcMean2, const Ipp32f* pSrcVar2,
       int len, Ipp64f* pResult, Ipp32f sumLog1, Ipp32f sumLog2))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsUpdateMean_*
//  Purpose:           Update the mean vector in the embedded EM
//                     training algorithm.
//  Parameters:
//    pMeanAcc         Pointer to the mean accumulator [len].
//    pMean            Pointer to the mean vector [len].
//    len              The legth of the mean vector [len].
//    meanOcc          The occupation sum of the Gaussian mixture.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pMean or pMeanAcc
//                     pointer is null.
//    ippStsZeroOcc    Indicates an error when meanOcc is equal to 0
//    ippStsNegOcc     Indicates an error when meanOcc is less than 0
//
*/

IPPAPI(IppStatus, ippsUpdateMean_32f, (const Ipp32f* pMeanAcc, Ipp32f* pMean,
       int len, Ipp32f meanOcc))

IPPAPI(IppStatus, ippsUpdateMean_64f, (const Ipp64f* pMeanAcc, Ipp64f* pMean,
       int len, Ipp64f meanOcc))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsUpdateVar_*
//  Purpose:           Updates the variance vector in the EM training
//                     algorithm.
//  Parameters:
//    pMeanAcc         Pointer to the mean accumulator [len].
//    pVarAcc          Pointer to the variance accumulator [len].
//    pVarFloor        Pointer to the variance floor vector [len].
//    pVar             Pointer to the variance vector [len].
//    len              The legth of the mean and variance vectors [len].
//    meanOcc          The occupation sum of the Gaussian mixture.
//    varOcc           The square occupation sum of the variance mixture.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the or pMeanAcc or pVarAcc or pVar
//                     or pVarFloor pointer is null.
//    ippStsZeroOcc    Indicates an error when meanOcc or varOcc is equal to 0
//    ippStsNegOcc     Indicates an error when meanOcc and varOcc are less than 0
//    ippStsResFloor   Indicates a warning when all variances are floored.
//
*/

IPPAPI(IppStatus, ippsUpdateVar_32f, (const Ipp32f* pMeanAcc,
       const Ipp32f* pVarAcc, const Ipp32f* pVarFloor, Ipp32f* pVar, int len,
       Ipp32f meanOcc, Ipp32f varOcc))
IPPAPI(IppStatus, ippsUpdateVar_64f, (const Ipp64f* pMeanAcc,
       const Ipp64f* pVarAcc, const Ipp64f* pVarFloor, Ipp64f* pVar, int len,
       Ipp64f meanOcc, Ipp64f varOcc))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsUpdateWeight_*
//  Purpose:           Updates the weight values of Gaussian mixtures
//                     in the EM training algorithm.
//  Parameters:
//    pWgtAccm         Pointer to the weight accumulator [len].
//    pWgt             Pointer to the weight vector [len].
//    len              Number of mixtures in the HMM state.
//    pWgtSum          Pointer to the output sum of weight values.
//    wgtOcc           The nominator of the weight update equation.
//    wgtThresh        The threshold for the weight values.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the or pWgtAcc or pWgt or pWgtSum
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0
//    ippStsZeroOcc    Indicates an error when wgtOcc is equal to 0
//    ippStsNegOcc     Indicates an error when wgtOcc is less than 0
//    ippStsResFloor   Indicates a warning when all weights are floored.
//
*/

IPPAPI(IppStatus, ippsUpdateWeight_32f, (const Ipp32f* pWgtAcc, Ipp32f* pWgt,
       int len, Ipp32f* pWgtSum, Ipp32f wgtOcc, Ipp32f wgtThresh))

IPPAPI(IppStatus, ippsUpdateWeight_64f, (const Ipp64f* pWgtAcc, Ipp64f* pWgt,
       int len, Ipp64f* pWgtSum, Ipp64f wgtOcc, Ipp64f wgtThresh))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsUpdateGConst_*
//  Purpose:           Updates the fixed constant in the Gaussian output
//                     probability density function.
//  Parameters:
//    pVar             Pointer to the variance vector [len].
//    len              Dimension of the variance vector.
//    pDet             Pointer to the result value.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the or pVar or pDet pointer
//                     is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0
//    ippStsLnZeroArg  Indicates a warning for zero-valued input vector elements.
//                     Operation execution is not aborted. The result value is
//                     set to -Inf if there are no negative elements in the vector.
//    ippStsLnNegArg   Indicates a warning for negative input vector elements.
//                     Operation execution is not aborted. The result value is NaN.
//
*/

IPPAPI(IppStatus, ippsUpdateGConst_32f, (const Ipp32f* pVar, int len, Ipp32f* pDet))

IPPAPI(IppStatus, ippsUpdateGConst_64f, (const Ipp64f* pVar, int len, Ipp64f* pDet))

IPPAPI(IppStatus, ippsUpdateGConst_DirectVar_32f, (const Ipp32f* pVar, int len,
       Ipp32f* pDet))

IPPAPI(IppStatus, ippsUpdateGConst_DirectVar_64f, (const Ipp64f* pVar, int len,
       Ipp64f* pDet))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsOutProbPreCalc_*
//  Purpose:           Pre-calculates the part of Gaussian mixture output
//                     probability that is irrelevant to observation vectors.
//  Parameters:
//    pWeight          Pointer to the Gaussian mixture weight vector [len].
//    pGConst          Pointer to the constant vector calculated from
//                     ippsUpdateGConst [len].
//    pVal             Pointer to the resulting vector [len].
//    len              Number of mixtures in the HMM state.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the or pWeight or pGConst or pVal
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0
//
*/

IPPAPI(IppStatus, ippsOutProbPreCalc_32f, (const Ipp32f* pWeight,
       const Ipp32f* pGConst, Ipp32f* pVal, int len))

IPPAPI(IppStatus, ippsOutProbPreCalc_64f, (const Ipp64f* pWeight,
       const Ipp64f* pGConst, Ipp64f* pVal, int len))

IPPAPI(IppStatus, ippsOutProbPreCalc_32f_I, (const Ipp32f* pWeight,
       Ipp32f* pGConst, int len))

IPPAPI(IppStatus, ippsOutProbPreCalc_64f_I, (const Ipp64f* pWeight,
       Ipp64f* pGConst, int len))

IPPAPI(IppStatus, ippsOutProbPreCalc_32s, (const Ipp32s* pWeight,
       const Ipp32s* pGConst, Ipp32s* pVal, int len))

IPPAPI(IppStatus, ippsOutProbPreCalc_32s_I, (const Ipp32s* pWeight,
       Ipp32s* pGConst, int len))

/*///////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDcsClustLAccumulate_*
//  Purpose:           Update the accumulators for calculating state-cluster
//                     likelihood in the desition-tree clustering algorithm.
//  Parameters:
//    pMean            Pointer to the mean vector of the HMM state in the
//                     cluster [len]
//    pVar             Pointer to the variance vector of the HMM state in the
//                     cluster [len]
//    pDstSum          Pointer to the sum part of the accumulator [len]
//    pDstSqr          Pointer to the sqr part of the accumulator [len]
//    len              Length of the mean and variance vectors.
//    occ              Occupation count of the HMM state.
//  Return:
//    ippStsNoErr      Idicates no error
//    ippStsNullPtrErr Idicates an error when the pMean, pVar, pDstSum or
//                     pDstSqr pointer is null
//    ippStsSizeErr    Idicates an error when len is less than or equal to 0
//
*/
IPPAPI(IppStatus, ippsDcsClustLAccumulate_32f, (const Ipp32f* pMean,
       const Ipp32f* pVar, Ipp32f* pDstSum, Ipp32f* pDstSqr, int len, Ipp32f occ))

IPPAPI(IppStatus, ippsDcsClustLAccumulate_64f, (const Ipp64f* pMean,
       const Ipp64f* pVar, Ipp64f* pDstSum, Ipp64f* pDstSqr, int len, Ipp64f occ))

IPPAPI(IppStatus, ippsDcsClustLAccumulate_DirectVar_32f, (const Ipp32f* pMean,
       const Ipp32f* pVar, Ipp32f* pDstSum, Ipp32f* pDstSqr, int len, Ipp32f occ))

IPPAPI(IppStatus, ippsDcsClustLAccumulate_DirectVar_64f, (const Ipp64f* pMean,
       const Ipp64f* pVar, Ipp64f* pDstSum, Ipp64f* pDstSqr, int len, Ipp64f occ))

/*///////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDcsClustLCompute_*
//  Purpose:           Calculate the likelihood of an HMM state cluster in the
//                     decision-tree state-clustering algorithm.
//  Parameters:
//    pSrcSum          Pointer to the sum part of the accumulator [len]
//    pSrcSqr          Pointer to the sqr part of the accumulator [len]
//    len              Length of the mean and variance vectors.
//    pDst             Pointer to the resulting likelihood value
//    occ              Ocupation sum of the HMM state cluster
//
//  Return:
//    ippStsNoErr      Idicates no error
//    ippStsNullPtrErr Idicates  an error when the pSrcSum, pSrcSqr,
//                     pDst pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0 or
//                     occ is less than or equal to 0.
//    ippStsZeroOcc    Indicates an error when occ is equal to 0
//    ippStsNegOcc     Indicates an error when occ is less than 0
//    ippStsLnZeroArg  Indicates a warning for zero-valued input vector elements.
//                     Operation execution is not aborted. The result value is
//                     set to -Inf if there are no negative elements in the
//                     vector.
//    ippStsLnNegArg   Indicates a warning for negative input vector elements.
//                     Operation execution is not aborted. The result value
//                     is set to NaN.
//
*/

IPPAPI(IppStatus, ippsDcsClustLCompute_32f64f, (const Ipp32f* pSrcSum,
       const Ipp32f* pSrcSqr, int len, Ipp64f* pDst, Ipp32f occ))

IPPAPI(IppStatus, ippsDcsClustLCompute_64f, (const Ipp64f* pSrcSum,
       const Ipp64f* pSrcSqr, int len, Ipp64f* pDst, Ipp64f occ))


/* /////////////////////////////////////////////////////////////////////////////
//  Model Adaptation
///////////////////////////////////////////////////////////////////////////// */
/*/////////////////////////////////////////////////////////////////////////////
//  Name:              ippsAddMulColumn_64f_D2L
//  Purpose:           Adds a weighted matrix column to another column.
//
//  Parameters:
//    mSrcDst          Pointer to the source and destination
//                     matrix [height][width].
//    width            The number of columns in the matrix mSrcDst.
//    height           The number of rows in the matrix mSrcDst.
//    col1             The first number of the column.
//    col2             The second number of the column.
//    row1             The first number of the row.
//    val              The multiplier factor.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrcDst pointer is null.
//    ippStsSizeErr    Indicates an error when when height, width
//                     is less than or equal to 0;
//                     or col1 or col2 is greater than or equal to width;
//                     or row1 is greater than or equal to  height;
//                     or col1 or col2 or row1 is less than 0.
//
*/
IPPAPI(IppStatus, ippsAddMulColumn_64f_D2L, (Ipp64f** mSrcDst, int width,
       int height, int col1, int col2, int row1, const Ipp64f val))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsAddMulRow_64f
//  Purpose:           Multiplies sourceh vector elements by a value
//                     and places them in the destination vector.
//
//  Parameters:
//    pSrc             Pointer to the source vector [len]
//    pDst             Pointer to the result vector [len]
//    len              Length  of source vector
//    val              The multiplying coefficient
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNoErr      Indicates an error when the pSrc or pDst is null
//    ippStsSizeErr    Indicates an error when the len is less or equal 0
//
*/
IPPAPI(IppStatus, ippsAddMulRow_64f, (const Ipp64f *pSrc, Ipp64f *pDst,
       int len, const Ipp64f val))

/*/////////////////////////////////////////////////////////////////////////////
//  Name:              ippsQRTransColumn_64f_D2L
//  Purpose:           Calculates QR transformation.
//
//  Parameters:
//    mSrcDst          Pointer to the source and destination
//                     matrix [height][width].
//    width            The number of columns in the matrix mSrcDst.
//    height           The number of rows in the matrix mSrcDst.
//    col1             The first number of the column.
//    col2             The second number of the column.
//    val1             The first multiplier factor.
//    val2             The second multiplier factor.
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrcDst pointer is null.
//    ippStsSizeErr    Indicates an error when height, width
//                     is less than or equal to 0;
//                     or col1 or col2 is greater than or equal to width.
//                     or col1 or col2 is less than 0.
//
*/
IPPAPI(IppStatus, ippsQRTransColumn_64f_D2L, (Ipp64f** mSrcDst, int width,
       int height, int col1, int col2, const Ipp64f val1, const Ipp64f val2))


/*/////////////////////////////////////////////////////////////////////////////
//  Name:              ippsDotProdColumn_64f_D2L
//  Purpose:           Calculates the dot product of two matrix columns.
//
//  Parameters:
//    mSrc             Pointer to the source matrix [height][width].
//    width            The number of columns in the matrix mSrc.
//    height           The number of rows in the matrix mSrc.
//    pSum             Pointer to the value of the computed sum.
//    col1             The first number of the column.
//    col2             The second number of the column.
//    row1             The first number of the row.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrcor pSum pointer is null.
//    ippStsSizeErr    Indicates an error when height, width
//                     is less than or equal to 0;
//                     or row1 is greater than or equal to  height;
//                     or col1 is  greater than or equal to width;
//                     or row1 or col1 is less than 0.
//
*/
IPPAPI(IppStatus, ippsDotProdColumn_64f_D2L, (const Ipp64f** mSrc, int width,
       int height, Ipp64f* pSum, int col1, int col2, int row1))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsMulColumn_64f_D2L
//  Purpose:           Multiplies a matrix column by a value.
//
//  Parameters:
//    mSrcDst          Pointer to the source and destination
//                     matrix [height][width].
//    width            The number of columns in the matrix mSrcDst.
//    height           The number of rows in the matrix mSrcDst.
//    col1             The first number of the column.
//    row1             The first number of the row.
//    val              The multiplier factor.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrcDst pointer is null.
//    ippStsSizeErr    Indicates an error when height, width
//                     is less than or equal to 0;
//                     or row1 is greater than or equal to height;
//                     or col1 is greater than or equal to width;
//                     or row1 or col1 is less than 0.
//
*/
IPPAPI(IppStatus, ippsMulColumn_64f_D2L, (Ipp64f** mSrcDst, int width,
       int height, int col1, int row1, const Ipp64f val))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSumColumnAbs_64f_D2L
//  Purpose:           Sums absolute values of column elements.
//
//  Parameters:
//    mSrc             Pointer to the source matrix [height][width].
//    width            The number of columns in the matrix mSrc.
//    height           The number of rows in the matrix mSrc.
//    pSum             Pointer to the value of the computed sum.
//    col1             The first number of the column.
//    row1             The first number of the row.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrc or pSum pointer is null.
//    ippStsSizeErr    Indicates an error when width, height
//                     is less than or equal to 0;
//                     or row1 is greater than or equal to height;
//                     or col1 is greater than or equal to width;
//                     or row1 or col1 is less than 0.
//
*/
IPPAPI(IppStatus, ippsSumColumnAbs_64f_D2L, (const Ipp64f** mSrc, int width,
       int height, Ipp64f* pSum, int col1, int row1))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSumColumnSqr_64f_D2L
//  Purpose:           Multiplies matrix column elements by a value and
//                     sums their squares.
//
//  Parameters:
//    mSrcDst          Pointer to the source matrix [height][width].
//    width            The number of columns in the matrix mSrcDst.
//    height           The number of rows in the matrix mSrcDst.
//    pSum             Pointer to the value of the computed sum.
//    col1             The first number of the column.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mSrcDst or pSum
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when width, height
//                     is less than or equal to 0;
//                     or row1 is greater than or equal to height;
//                     or col1 is greater than or equal to width.
//                     or row1 or col1 is less than 0.
//
*/
IPPAPI(IppStatus, ippsSumColumnSqr_64f_D2L, (Ipp64f** mSrcDst, int width,
       int height, Ipp64f* pSum, int col1, int row1, const Ipp64f val))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSumRowAbs_64f
//  Purpose:           Sums absolute values of vector elements.
//
//  Parameters:
//    pSrc             Pointer to the source vector [len].
//    pSum             Pointer to the value of the computed sum.
//    len              The number of elements in the source vector pSrc.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pSum pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsSumRowAbs_64f, (const Ipp64f *pSrc, int len, Ipp64f *pSum))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSumRowSqr_64f
//  Purpose:           Multiplies vector elements by a value and sums
//                     their squares.
//
//  Parameters:
//    pSrcDst          Pointer to the source vector [len].
//    len              The number of elements in the source vector pSrcDst.
//    pSum             Pointer to the value of the computed sum.
//    val              The multiplier factor.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcDst or pSum
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when lenis less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsSumRowSqr_64f, (Ipp64f *pSrcDst,
       int len, Ipp64f *pSum, const Ipp64f val))

/*///////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSVD__*, ippsSVDSort__*
//  Purpose:           Performs Single Value Decomposition on a matrix.
//
//  Parameters:
//    pSrcA            Pointer to the input vector A [height*step].
//    pDstU            Ppointer to the output vector U [height*step].
//    pSrcDstA         Pointer to the input matrix A and output
//                     matrix U [height*step].
//    pDstV            Pointer to the output vector V [width*step].
//    mSrcA            Pointer to the input matrix A [height][width].
//    mDstU            Pointer to the output matrix U [height][width].
//    mSrcDstA         Pointer to the input matrix A and output
//                     matrix U [height][width].
//    pDstW            Pointer to the output vector W [width].
//    mDstV            Pointer to the output matrix V [width][width].
//    height           Number of rows in the input matrix.
//    width            Number of columns in the input matrix.
//    step             Row step in pSrcA, pSrcDstA, and pDstV.
//    nIter            Number of iteration for diagonalization.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrcA, pSrcDstA, pDstV, mSrcA,
//                     mDstU, mSrcDstA, pDstW or mDstV pointer is null.
//    ippStsSizeErr    Indicates an error when heigh, width, step or nIter is less
//                     than or equal to 0 or width is greater than step;
//    ippStsSVDCnvg    Indicates an error when SVD algorithm was not converged for
//                     nIter iterations.
//
*/

IPPAPI(IppStatus, ippsSVD_64f_D2,(const Ipp64f* pSrcA, Ipp64f* pDstU, int height,
       Ipp64f* pDstW, Ipp64f* pDstV, int width, int step, int nIter))

IPPAPI(IppStatus, ippsSVD_64f_D2_I,(Ipp64f* pSrcDstA, int height, Ipp64f* pDstW,
       Ipp64f* pDstV, int width, int step, int nIter))

IPPAPI(IppStatus, ippsSVD_64f_D2L,(const Ipp64f** mSrcA, Ipp64f** mDstU, int height,
       Ipp64f* pDstW, Ipp64f** mDstV, int width, int nIter))

IPPAPI(IppStatus, ippsSVD_64f_D2L_I,(Ipp64f** mSrcDstA, int height, Ipp64f* pDstW,
       Ipp64f** mDstV, int width, int nIter))

IPPAPI(IppStatus, ippsSVDSort_64f_D2,(const Ipp64f* pSrcA, Ipp64f* pDstU, int height,
       Ipp64f* pDstW, Ipp64f* pDstV, int width, int step, int nIter))

IPPAPI(IppStatus, ippsSVDSort_64f_D2_I,(Ipp64f* pSrcDstA, int height, Ipp64f* pDstW,
       Ipp64f* pDstV, int width, int step, int nIter))

IPPAPI(IppStatus, ippsSVDSort_64f_D2L,(const Ipp64f** mSrcA, Ipp64f** mDstU, int height,
       Ipp64f* pDstW, Ipp64f** mDstV, int width, int nIter))

IPPAPI(IppStatus, ippsSVDSort_64f_D2L_I,(Ipp64f** mSrcDstA, int height, Ipp64f* pDstW,
       Ipp64f** mDstV, int width, int nIter))


/*///////////////////////////////////////////////////////////////////////////////
//  Name:              ippsWeightedSum_*
//  Purpose:           Calculates the weighted sums of two input vector elements.
//  Parameters:
//    pSrc1            Pointer to the first input vector [len].
//    pSrc2            Pointer to the second input vector [len].
//    pDst             Pointer to the output vector [len]
//    len              The length of the input an output vectors.
//    weight1          The first weight value.
//    weight2          The second weight value.
//
//  Returns:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc1, pSrc2 or pDst
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0
//    ippStsDivByZero  Indicates a warning for zero-valued divisor vector
//                     element. Operation execution is not aborted. The value of
//                     the destination vector element in the floating-point operations:
//                     NaN    For zero-valued dividend vector element.
//                     +Inf    For positive dividend vector element.
//                     -Inf    For negative dividend vector element.
//
*/
IPPAPI(IppStatus, ippsWeightedSum_16s, (const Ipp16s* pSrc1,
       const Ipp16s* pSrc2, Ipp16s* pDst, int len, Ipp32f weight1,
       Ipp32f weight2))

IPPAPI(IppStatus, ippsWeightedSum_32f, (const Ipp32f* pSrc1,
       const Ipp32f* pSrc2, Ipp32f* pDst, int len, Ipp32f weight1,
       Ipp32f weight2))

IPPAPI(IppStatus, ippsWeightedSum_64f, (const Ipp64f* pSrc1,
       const Ipp64f* pSrc2, Ipp64f* pDst, int len, Ipp64f weight1,
       Ipp64f weight2))

IPPAPI(IppStatus, ippsWeightedSumHalf_32f, (const Ipp32f* pSrc1,
       const Ipp32f* pSrc2, Ipp32f* pDst, int len, Ipp32f weight1,
       Ipp32f weight2))

IPPAPI(IppStatus, ippsWeightedSumHalf_64f, (const Ipp64f* pSrc1,
       const Ipp64f* pSrc2, Ipp64f* pDst, int len, Ipp64f weight1,
       Ipp64f weight2))


IPPAPI(IppStatus, ippsWeightedSumHalf_16s, (const Ipp16s* pSrc1,
       const Ipp16s* pSrc2, Ipp16s* pDst, int len, Ipp32f weight1,
       Ipp32f weight2))


/* /////////////////////////////////////////////////////////////////////////////
//  Vector Quantization
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsFormVector_*
//  Purpose:           Composes a vector from four element chunks.
//  Parameters:
//    pInd             Pointer to the input vector of codebook indexes [nStream].
//    mSrc             Pointer to the vector of pointers to source lookup
//                     tables [nStream].
//    pHeights         Pointer to the vector of codebook lengths [nStream].
//    pWidths          Pointer to the vector of codebook entry lengths [nStream].
//    pSteps           Pointer to the vector of codebook row pSteps [nStream].
//    nStream          The number of codebooks.
//    pDst             Pointer to the output vector [len].
//    len              The length of the output vector.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the the pInd, mSrc, pHeights,
//                     pWidths, pSteps, pDst or mSrc[k].
//    ippStsSizeErr    Indicates an error when len , nStream, pHeights[k],
//                     pWidths[k] or pSteps[k] is less than or equal to 0 .
*/
IPPAPI(IppStatus, ippsFormVector_4i_8u16s, (const Ipp8u* pInd,
       const Ipp16s** mSrc, const Ipp32s* pHeights, Ipp16s* pDst, int len))

IPPAPI(IppStatus, ippsFormVector_4i_16s16s, (const Ipp16s* pInd,
       const Ipp16s** mSrc, const Ipp32s* pHeights, Ipp16s* pDst, int len))

IPPAPI(IppStatus, ippsFormVector_4i_8u32f, (const Ipp8u* pInd,
       const Ipp32f** mSrc, const Ipp32s* pHeights, Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsFormVector_4i_16s32f, (const Ipp16s* pInd,
       const Ipp32f** mSrc, const Ipp32s* pHeights, Ipp32f* pDst, int len))


IPPAPI(IppStatus, ippsFormVector_2i_8u16s, (const Ipp8u* pInd,
       const Ipp16s** mSrc, const Ipp32s* pHeights, Ipp16s* pDst, int len))

IPPAPI(IppStatus, ippsFormVector_2i_16s16s, (const Ipp16s* pInd,
       const Ipp16s** mSrc, const Ipp32s* pHeights, Ipp16s* pDst, int len))

IPPAPI(IppStatus, ippsFormVector_2i_8u32f, (const Ipp8u* pInd,
       const Ipp32f** mSrc, const Ipp32s* pHeights, Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsFormVector_2i_16s32f, (const Ipp16s* pInd,
       const Ipp32f** mSrc, const Ipp32s* pHeights, Ipp32f* pDst, int len))


IPPAPI(IppStatus, ippsFormVector_8u16s, (const Ipp8u* pInd,
       const Ipp16s** mSrc, const Ipp32s* pHeights, const Ipp32s* pWidths,
       const Ipp32s* pSteps, int nStream, Ipp16s* pDst))

IPPAPI(IppStatus, ippsFormVector_16s16s, (const Ipp16s* pInd,
       const Ipp16s** mSrc, const Ipp32s* pHeights, const Ipp32s* pWidths,
       const Ipp32s* pSteps, int nStream, Ipp16s* pDst))

IPPAPI(IppStatus, ippsFormVector_8u32f, (const Ipp8u* pInd,
       const Ipp32f** mSrc, const Ipp32s* pHeights, const Ipp32s* pWidths,
       const Ipp32s* pSteps, int nStream, Ipp32f * pDst))

IPPAPI(IppStatus, ippsFormVector_16s32f, (const Ipp16s* pInd,
       const Ipp32f** mSrc, const Ipp32s* pHeights, const Ipp32s* pWidths,
       const Ipp32s* pSteps, int nStream, Ipp32f * pDst))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsCdbkInitAlloc_L2_*
//  Purpose:           Initializes the codebook structure.
//
//  Parameters:
//    pCdbk            Pointer to the codebook structure to be created.
//    pSrc             Pointer to the source vector [height*step].
//    width            Length of input vectors.
//    step             Row step in pSrc.
//    height           Number of rows in pSrc.
//    cdbkSize         Required number of codevectors.
//    hint             One of the following values:
//                     IPP_CDBK_FULL    The source data are treated as a codebook,
//                                      height should be greater or equal to
//                                      nCluster. The nearest codebook entry is
//                                      found by a full search.
//                     IPP_CDBK_KMEANS_LONG LBG algorithm with splitting of the
//                                      most extensional cluster is used for
//                                      the codebook building. The nearest
//                                      codebook entry is located through
//                                      a logarithmical search.
//                     IPP_CDBK_KMEANS_NUM LBG algorithm with splitting of
//                                      the most numerous clusters is used for
//                                      the codebook building. The nearest
//                                      codebook entry is located through
//                                      a logarithmical search.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc pointer is null.
//    ippStsSizeErr    Indicates an error when width, step, or cdbkSize
//                     is less than or equal to 0;
//                     or cdbkSizeis greater than height;
//                     or width is greater than step;
//                     or cdbkSize is greater than 16383;
//                     or hintis equal to IPP_CDBK_FULL and cdbkSizeis not equal
//                     to height.
//    ippStsCdbkFlagErr
//                      Indicates an error when the hint value is incorrect.
//    ippStsMemAllocErr Indicates an error when no memory allocated.
//
*/

IPPAPI(IppStatus, ippsCdbkInitAlloc_L2_16s,(IppsCdbkState_16s** pCdbk,
       const Ipp16s* pSrc, int width, int step, int height, int nCluster,
       Ipp_Cdbk_Hint hint))

IPPAPI(IppStatus, ippsCdbkInitAlloc_L2_32f,(IppsCdbkState_32f** pCdbk,
       const Ipp32f* pSrc, int width, int step, int height, int nCluster,
       Ipp_Cdbk_Hint hint))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsCdbkInitAlloc_WgtL2_*
//  Purpose:        Initializes the structure that contains the codebook
//                  and additional information to be used for fast search.
//
//  Parameters:
//    pCdbk            Pointer to the codebook structure to be created.
//    pSrc             Pointer to the source vector [height*step].
//    pWgt             Pointer to the weights vector [width].
//    width            Length of input vectors.
//    step             Row step in pSrc.
//    height           Number of rows in pSrc.
//    cdbkSize         Required number of codevectors.
//    hint             One of the following values:
//    IPP_CDBK_FULL    The source data are treated as a codebook, height should
//                     be greater or equal to nCluster. The nearest codebook
//                     entry is found by a full search.
//
//      IPP_CDBK_LBG_LONG
//                       LBG algorithm with splitting of the most extensious
//                       cluster is used for the codebook building. The nearest
//                       codebook entry is found by a logarithmical search.
//
//      IPP_CDBK_LBG_NUM LBG algorithm with splitting of the most numerous
//                       clusters is used for the codebook building. The nearest
//                       codebook entry is found by a logarithmical search
//  Return:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc pointer is null.
//    ippStsSizeErr    Indicates an error when width, step, height or cdbkSize
//                     is less than or equal to 0 or width is greater than step
//                     or cdbkSize is greater than 16383;
//    ippStsCdbkFlagErr
//                      Indicates an error when the hint value is incorrect.
//    ippStsMemAllocErr Indicates an error when no memory allocated.
//  Notes:
*/

IPPAPI(IppStatus, ippsCdbkInitAlloc_WgtL2_32f,(IppsCdbkState_32f** pCdbk, const Ipp32f* pSrc,
       const Ipp32f* pWgt, int width, int step, int height, int cdbkSize, Ipp_Cdbk_Hint hint))

IPPAPI(IppStatus, ippsCdbkInitAlloc_WgtL2_16s,(IppsCdbkState_16s** pCdbk, const Ipp16s* pSrc,
       const Ipp16s* pWgt, int width, int step, int height, int cdbkSize, Ipp_Cdbk_Hint hint))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsCdbkFree_*
//  Purpose:           Destroys the codebook structure a
//
//  Parameters:
//      pCdbk          Pointer to the codebook structure.
//  Return:
//    ippStsNoErr     Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pCdbk pointer is null.
//
*/

IPPAPI(IppStatus, ippsCdbkFree_16s,(IppsCdbkState_16s* pCdbk))

IPPAPI(IppStatus, ippsCdbkFree_32f,(IppsCdbkState_32f* pCdbk))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsGetCdbkSize_*
//  Purpose:           Retrieves the number of codevectors in the codebook.
//
//  Parameters:
//    pCdbk            Pointer to the codebook structure.
//    pNum             Pointer to the result number of codevectors.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pCdbk or pNum pointer is null.
//
*/

IPPAPI(IppStatus, ippsGetCdbkSize_16s,(const IppsCdbkState_16s* pCdbk, int* pNum))

IPPAPI(IppStatus, ippsGetCdbkSize_32f,(const IppsCdbkState_32f* pCdbk, int* pNum))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsGetCodebook_*
//  Purpose:           Retrieves the number of codevectors in the codebook pCdbk.
//
//  Parameters:
//    pCdbk            Pointer to the codebook structure.
//    pDst             Pointer to the destination vector for codevectors
//                     [pNum[0]* step].
//    step             Row step in the destination vector pDst.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pDst or pNum pointer is null.
//
*/

IPPAPI(IppStatus, ippsGetCodebook_16s,(const IppsCdbkState_16s* pCdbk,
       Ipp16s* pDst, int step))

IPPAPI(IppStatus, ippsGetCodebook_32f,(const IppsCdbkState_32f* pCdbk,
       Ipp32f* pDst, int step))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsVQ_*
//  Purpose:           Quantizes the input vectors given a codebook.
//
//  Parameters:
//    pCdbk            Pointer to the codebook structure.
//    pSrc             Pointer to the source vector [height*step].
//    step             Row step in pSrc.
//    height           Number of rows in pSrc.
//    pIndx            Pointer to the destination vector of closiest codevector
//                     numbers [height].
//    pDist            Pointer to the destination vector of distance to for
//                     closiest codevector [height].
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pCdbk, pSrc, pIndx  or pDist
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when step is less than or equal to 0 or
//                     is step is less than width.
//    ippStsSizeErr    Indicates an error when width, step, height is less than
//                     or equal to 0 or width is greater than step;
//
*/

IPPAPI(IppStatus, ippsVQ_16s,(const Ipp16s* pSrc, int step, Ipp32s* pIndx,
       int height, const IppsCdbkState_16s* pCdbk))

IPPAPI(IppStatus, ippsVQ_32f,(const Ipp32f* pSrc, int step, Ipp32s* pIndx,
       int height, const IppsCdbkState_32f* pCdbk))

IPPAPI(IppStatus, ippsVQDist_16s32s_Sfs,(const Ipp16s* pSrc, int step,
       Ipp32s* pIndx, Ipp32s* pDist, int height, const IppsCdbkState_16s* pCdbk,
       int scaleFactor))

IPPAPI(IppStatus, ippsVQDist_32f,(const Ipp32f* pSrc, int step, Ipp32s* pIndx,
       Ipp32f* pDist, int height, const IppsCdbkState_32f* pCdbk))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsSplitVQ_*
//  Purpose:           Quantizes a multiple-stream vector given the codebooks.
//
//  Parameters:
//    pCdbks           Pointer to the vector of pointers to codebook
//                     structure [nStream].
//    pSrc             Pointer to the source vector [height*srcStep].
//    pDst             Pointer to the destination vector [height*dstStep].
//    srcStep          Row step in pSrc.
//    dstStep          Row step in pDst.
//    dstBitStep       Row step in pDst in bits
//    height           Number of rows in pSrc.
//    nStream          Number of chunks in input vectors.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pCdbk, pCdbk[k], pSrc or pDst
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when srcStep, dstStep, height or
//                     nStream is less than or equal to 0 or chunk length sum
//                     is greater than srcStep or  nStream is greater than
//                     dstStep for functions with 16s or 8u output or number of
//                     bits to represent output indexes sequence is greater than
//                     dstStep for functions with 1u output or codebook size is
//                     greater than 256 for functions with 8u output.
//
*/

IPPAPI(IppStatus, ippsSplitVQ_16s16s,(const Ipp16s* pSrc, int srcStep, Ipp16s* pDst,
       int dstStep, int height,const IppsCdbkState_16s** pCdbks, int nStream))

IPPAPI(IppStatus, ippsSplitVQ_16s8u,(const Ipp16s* pSrc, int srcStep, Ipp8u* pDst,
       int dstStep, int height,const IppsCdbkState_16s** pCdbks, int nStream))

IPPAPI(IppStatus, ippsSplitVQ_16s1u,(const Ipp16s* pSrc, int srcStep, Ipp8u* pDst,
       int dstBitStep, int height,const IppsCdbkState_16s** pCdbks, int nStream))

IPPAPI(IppStatus, ippsSplitVQ_32f16s,(const Ipp32f* pSrc, int srcStep, Ipp16s* pDst,
       int dstStep, int height,const IppsCdbkState_32f** pCdbks, int nStream))

IPPAPI(IppStatus, ippsSplitVQ_32f8u,(const Ipp32f* pSrc, int srcStep, Ipp8u* pDst,
       int dstStep, int height,const IppsCdbkState_32f** pCdbks, int nStream))

IPPAPI(IppStatus, ippsSplitVQ_32f1u,(const Ipp32f* pSrc, int srcStep, Ipp8u* pDst,
       int dstBitStep, int height,const IppsCdbkState_32f** pCdbks, int nStream))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsFormVectorVQ_*
//  Purpose:           Constructs multiple-stream vectors from codebooks,
//                     given indexes.
//
//  Parameters:
//    pCdbks           Pointer to the vector of pointers to codebook
//                     structure [nStream].
//    pSrc             Pointer to the source vector [height*srcStep].
//    pDst             Pointer to the destination vector [height*dstStep].
//    srcStep          Row step in pSrc.
//    dstStep          Row step in pDst.
//    srcBitStep       Row step in pSrc in bits
//    height           Number of rows in pSrc.
//    nStream          Number of chunks in input vectors.
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pCdbk, pCdbk[k], pSrc or pDst
//                     pointer is null.
//    ippStsSizeErr    Indicates an error when srcStep, dstStep, height or
//                     nStream is less than or equal to 0 or codevector length
//                     sum is greater than dstStep or  nStream is greater than
//                     srcStep for functions with 16s or 8u output or number of bits
//                     to represent output indexes sequence is greater than srcStep
//                     for functions with 1u output.
//  Notes:
*/
IPPAPI(IppStatus, ippsFormVectorVQ_16s16s,(const Ipp16s* pSrc, int srcStep, Ipp16s* pDst,
       int dstStep, int height, const IppsCdbkState_16s** pCdbks, int nStream))

IPPAPI(IppStatus, ippsFormVectorVQ_8u16s,(const Ipp8u* pSrc, int srcStep, Ipp16s* pDst,
       int dstStep, int height, const IppsCdbkState_16s** pCdbks, int nStream))

IPPAPI(IppStatus, ippsFormVectorVQ_1u16s,(const Ipp8u* pSrc, int srcBitStep, Ipp16s* pDst,
       int dstStep, int height, const IppsCdbkState_16s** pCdbks, int nStream))

IPPAPI(IppStatus, ippsFormVectorVQ_16s32f,(const Ipp16s* pSrc, int srcStep, Ipp32f* pDst,
       int dstStep, int height, const IppsCdbkState_32f** pCdbks, int nStream))

IPPAPI(IppStatus, ippsFormVectorVQ_8u32f,(const Ipp8u* pSrc, int srcStep, Ipp32f* pDst,
       int dstStep, int height, const IppsCdbkState_32f** pCdbks, int nStream))

IPPAPI(IppStatus, ippsFormVectorVQ_1u32f,(const Ipp8u* pSrc, int srcBitStep, Ipp32f* pDst,
       int dstStep, int height, const IppsCdbkState_32f** pCdbks, int nStream))

/* /////////////////////////////////////////////////////////////////////////////
// Name:            IppStatus ippsCdbkInit_L2_*
//
// Description:         Initializes the structure that contains the codebook
//
//
// Input Arguments:  pCdbk               Pointer to the codebook structure to be initialized.
//                     pSrc              Pointer to the source vector [height*step].
//                     width             Length of input vectors.
//                     step              Row step in pSrc.
//                     height            Number of rows in pSrc.
//                     nCluster          Required number of codevectors.
//                     hint              One of the following values:
//                     IPP_CDBK_FULL     The source data are treated as a
//                        codebook, height should be greater or equal to
//                        nCluster. The nearest codebook entry is found by
//                        a full search.
//                     IPP_CDBK_LBG_LONG Not supported
//                     IPP_CDBK_LBG_NUM  Not supported
//
//
// Returns:            ippStsNoErr        - No Error.
//                     ippStsSizeErr      - Bad Arguments.
//                     ippStsCdbkFlagErr  - Hint not supported
//
// Notes:            The primitive does not support tree-based codebook
*/
IPPAPI(IppStatus, ippsCdbkInit_L2_16s,(IppsCdbkState_16s*    pCdbk,
                                        const Ipp16s*        pSrc,
                                        int                  width,
                                        int                  step,
                                        int                  height,
                                        int                  nCluster,
                                        Ipp_Cdbk_Hint        hint))

IPPAPI(IppStatus, ippsCdbkInit_L2_32f,(IppsCdbkState_32f*    pCdbk,
                                        const Ipp32f*        pSrc,
                                        int                  width,
                                        int                  step,
                                        int                  height,
                                        int                  nCluster,
                                        Ipp_Cdbk_Hint        hint))

/* /////////////////////////////////////////////////////////////////////////////
// Name:            IppStatus ippsCdbkGetSize_*
//
// Description:         Computes the size in bytes required for the codebook table
//
//
// Input Arguments:  width               Length of input vectors.
//                     step              Row step in pSrc.
//                     nCluster          Required number of codevectors.
//                     hint              One of the following values:
//                     IPP_CDBK_FULL     The source data are treated as a
//                        codebook, height should be greater or equal to
//                        nCluster. The nearest codebook entry is found by
//                        a full search.
//                     IPP_CDBK_LBG_LONG Not supported
//                     IPP_CDBK_LBG_NUM  Not supported
//
//
// Returns:            ippStsNoErr       - No Error.
//                     ippStsNullPtrErr  - Indicates an error when pSize pointer is null.
//                     ippStsSizeErr     - Indicates an error when width, step, height, or cdbkSize is less than
//                                         or equal to 0;  or width is greater than step;  or cdbkSize is greater than 16383; or height is not equal to cdbkSize.
//                     ippStsCdbkFlagErr - Indicates an error when the hint value is incorrect or not supported.
//
//
// Notes:
*/
IPPAPI(IppStatus, ippsCdbkGetSize_16s,(int                    width,
                                       int                    step,
                                       int                    height,
                                       int                    nCluster,
                                       Ipp_Cdbk_Hint          hint,
                                       int*                   pSize))

IPPAPI(IppStatus, ippsCdbkGetSize_32f,(int                    width,
                                       int                    step,
                                       int                    height,
                                       int                    nCluster,
                                       Ipp_Cdbk_Hint          hint,
                                       int*                   pSize))

/* /////////////////////////////////////////////////////////////////////////////
//  TTS Arithmetic
///////////////////////////////////////////////////////////////////////////// */

/*/////////////////////////////////////////////////////////////////////////////
//  Name:              ippsReflectionToAbsTilt_* / ippsReflectionToTilt_*
//  Purpose:           Calculates tilt for rise/fall/connection parameters.
//
//  Parameters:
//    pSrc1        Pointer to the first input vector [len].
//    pSrc2        Pointer to the second input vector [len].
//    pDst         Pointer to the destination vector [len].
//    len          Length of the input and output vectors.
//
//  Returns:
//    ippStsNoErr       Indicates no error.
//    ippStsNullPtrErr  Indicates an error when the pSrc1, pSrc2 or pDst
//                      pointer is null.
//    ippStsSizeErr     Indicates an error when len is less than or equal to 0.
//    ippStsDivByZero   Indicates a warning for zero-valued divisor vector
//                      element. Operation execution is not aborted. The value of
//                      the destination vector element in the floating-point
//                      operations:
//                         NaN For zero-valued dividend vector element.
//                         +Inf For positive dividend vector element.
//                         -Inf For negative dividend vector
//                      The value of the destination vector element in the
//                      integer operations:
//                         IPP_MAX_16S For positive dividend vector element.
//                         IPP_MIN_16S For negative dividend vector
//  Notes:
//             The function ippsReflectionToAbsTilt converts rise and fall
//             coefficients to absolute tilt.
//             The function ippsReflectionToTilt converts rise and fall
//             coefficients to tilt.
*/
IPPAPI(IppStatus, ippsReflectionToAbsTilt_16s_Sfs, (const Ipp16s* pSrc1,
       const Ipp16s* pSrc2, Ipp16s* pDst, int len, int scaleFactor))

IPPAPI(IppStatus, ippsReflectionToAbsTilt_32f, (const Ipp32f* pSrc1,
       const Ipp32f* pSrc2, Ipp32f* pDst, int len))

IPPAPI(IppStatus, ippsReflectionToTilt_16s_Sfs, (const Ipp16s* pSrc1,
       const Ipp16s* pSrc2, Ipp16s* pDst, int len, int scaleFactor))

IPPAPI(IppStatus, ippsReflectionToTilt_32f, (const Ipp32f* pSrc1,
       const Ipp32f* pSrc2, Ipp32f* pDst, int len))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussSingle_*
//  Purpose:           Calculates the observation probability for a
//                     single Gaussian with an observation vector.
//
//  Parameters:
//    pSrc             Pointer to the input vector [len].
//    pMean            Pointer to the mean vector [len].
//    pVar             Pointer to the variance vector [len].
//    pBlockVar        Pointer to the block diagonal variance matrix.
//    len              Number of elements in the input, mean, and variance
//                     vectors.
//    pResult          Pointer to the result value.
//    val              Gaussian constant.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar, or
//                     pResult or pBlockVar pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0.
//
*/
/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussSingle_Low_16s32s_Sfs,(const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int len, Ipp32s* pResult,
       Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussSingle_LowScaled_16s32f,(const Ipp16s* pSrc, const Ipp16s* pMean,
       const Ipp16s* pVar, int len, Ipp32f* pResult, Ipp32f val, int scaleFactor))

/*
//Case 3: Operation for the identity covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussSingle_IdVarLow_16s32s_Sfs,(const Ipp16s* pSrc,
       const Ipp16s* pMean, int len, Ipp32s* pResult, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussSingle_IdVarLowScaled_16s32f,(const Ipp16s* pSrc,
       const Ipp16s* pMean, int len, Ipp32f* pResult, Ipp32f val, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGauss_*
//  Purpose:           Calculates the observation probability for a single
//                     Gaussian with multiple observation vectors.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    mSrc             Pointer to the input matrix [height][ width].
//    step             The row step in pSrc.
//    pMean            Pointer to the mean vector [width].
//    pVar             Pointer to the variance vector [width].
//    width            Length of the mean and variance vectors.
//    pDst             Pointer to the result value [height].
//    pSrcDst          Pointer to the input and output vector [height].
//    height           The number of rows in the input matrix and the length of
//                     the result vector pDst.
//    val              Gaussian constant.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pDst,or mSrc pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGauss_Low_16s32s_D2Sfs, (const Ipp16s* pSrc, int step,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32s* pDst,
       int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_Low_16s32s_D2LSfs, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32s* pDst,
       int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_LowScaled_16s32f_D2, (const Ipp16s* pSrc, int step,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32f* pDst,
       int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_LowScaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32f* pDst,
       int height, Ipp32f val, int scaleFactor))

/*
//Case 2: Operation for the identity covariance matrix
*/

IPPAPI(IppStatus, ippsLogGauss_IdVarLow_16s32s_D2Sfs,(const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32s* pDst, int height,
       Ipp32s val,int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_IdVarLowScaled_16s32f_D2,(const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32f* pDst, int height,
       Ipp32f val,int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_IdVarLow_16s32s_D2LSfs,(const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32s* pDst, int height, Ipp32s val,
       int scaleFactor))

IPPAPI(IppStatus, ippsLogGauss_IdVarLowScaled_16s32f_D2L,(const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32f* pDst, int height, Ipp32f val,
       int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussMultiMix_*
//  Purpose:           Calculates the observation probability for
//                     multiple Gaussian mixture components.
//
//  Parameters:
//    pMean            Pointer to the variance vector [height*step].
//    mMean            Pointer to the mean matrix [height][width].
//    mVar             Pointer to the variance matrix [height][width].
//    pSrcDst          Pointer to the input additive values and
//                     the result vector [height].
//    step             The row step in pMean.
//    pSrc             Pointer to the input vector [width].
//    height           The number of rows in input matrices and the length of
//                     the result vector pSrcDst.
//    width            The length of the input matrices row and the vector pSrc.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst, mMean, or mVar pointer is null.
//    ippStsSizeErr    Indicates an error when heightor width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsLogGaussMultiMix_Low_16s32s_D2Sfs, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
       Ipp32s* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMultiMix_Low_16s32s_D2LSfs, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, Ipp32s* pSrcDst,
       int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMultiMix_LowScaled_16s32f_D2, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
       Ipp32f* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMultiMix_LowScaled_16s32f_D2L, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, Ipp32f* pSrcDst,
       int height, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussMax_*_D2
//  Purpose:           Computes maximum  value of a vector dst and
//                     logarithms of the Gaussian probability distribution function.
//  Parameters:
//    pSrc             Pointer to the input vector [height*step].
//    step             The row step in pSrc.
//    pMean            Pointer to the mean vector [width].
//    pVar             Pointer to the variance vector [width].
//    width            The length of the input matrix row, mean,
//                     and variance vectors.
//    pSrcDst          Pointer to the input and output vector [height].
//    height           The number of rows in the input matrix and the length of
//                     the result vector pDst.
//    val              The value to add to each distance.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussMax_Low_16s32s_D2Sfs, (const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, const Ipp16s* pVar, int width,
       Ipp32s* pSrcDst, int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_Low_16s32s_D2LSfs, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s*  pVar, int width, Ipp32s* pDst,
                  int height, Ipp32s  val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_LowScaled_16s32f_D2, (const Ipp16s* pSrc, int step,
       const Ipp16s* pMean, const Ipp16s* pVar, int width,
       Ipp32f* pSrcDst, int height, Ipp32f val, int scaleFacto))

IPPAPI(IppStatus, ippsLogGaussMax_LowScaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s*  pVar, int width, Ipp32f* pDst,
      int height, Ipp32f  val, int scaleFacto))

/*
//Case 2: Operation for the identity covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussMax_IdVarLow_16s32s_D2Sfs, (const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32s* pSrcDst,
       int height, Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_IdVarLow_16s32s_D2LSfs, (const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32s* pSrcDst, int height,
       Ipp32s val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_IdVarLowScaled_16s32f_D2, (const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMax_IdVarLowScaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32f* pSrcDst, int height,
       Ipp32f val, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussMaxMultiMix_*_*
//  Purpose:           Computes the maximum of the Gaussian probability
//                     distribution function.
//  Parameters:
//    pMean            Pointer to the mean vector of length [height*step].
//    pVar             Pointer to the variance vector of length [height*step].
//    mMean            Pointer to the mean matrix of size [height][width].
//    mVar             Pointer to the mean matrix of size [height][width].
//    pVal             Pointer to the input vector of Maxitive values [height].
//    pSrcDst          Pointer to the input and output vector of length [height].
//    step             Row step in pMean and pVar.
//    pSrc             Pointer to theinput vector of length[width].
//    height           Number of rows in input matrices and the length of
//                     the result vector pSrcDst.
//    width            Length of the input matrices row and the vector pSrc.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst or mMean or mVar or pVal pointer is null.
//    ippStsSizeErr    Indicates an error when height or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_LowScaled_16s32f_D2, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc,int width,
       const Ipp32f* pVal, Ipp32f* pSrcDst,int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_LowScaled_16s32f_D2L, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, const Ipp32f* pVal,
       Ipp32f* pSrcDst,int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_Low_16s32s_D2Sfs, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
       const Ipp32s* pVal, Ipp32s* pSrcDst,int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMaxMultiMix_Low_16s32s_D2LSfs, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, const Ipp32s* pVal,
       Ipp32s* pSrcDst,int height, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussAdd_32f_D2
//  Purpose:           Calculates the likelihood probability for multiple
//                     observation vectors.
//
//  Parameters:
//    pSrc             Pointer to the first input vector of length [width*height]
//    step             Row step in pSrc.
//    pMean            Pointer to the mean vector of length [width]
//    pVar             Pointer to the variance vector of length [width]
//    width            Length of the mean, and variance vectors.
//    pSrcDst          Pointer to input vector and output vector [height]
//    height           Length of  the input and output vector pSrcDst
//    val              Value to add to each distance.
//
//  Returns:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean,pVar,
//                     pSrcDst pointer is null.
//    ippStsSizeErr    Indicates an error when width or height
//                     is less than or equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
*/
/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussAdd_LowScaled_16s32f_D2,(const Ipp16s* pSrc, int step,
       const Ipp16s* pMean, const Ipp16s* pVar, int width,
       Ipp32f* pSrcDst, int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAdd_LowScaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val, int scaleFactor))

/*
//Case 2: Operation for the identity covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussAdd_IdVarLowScaled_16s32f_D2,(const Ipp16s* pSrc,
       int step, const Ipp16s* pMean, int width, Ipp32f* pSrcDst,
       int height, Ipp32f val, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAdd_IdVarLowScaled_16s32f_D2L,(const Ipp16s** mSrc,
       const Ipp16s* pMean, int width, Ipp32f* pSrcDst, int height, Ipp32f val,
       int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogGaussAddMultiMix_*_*
//  Purpose:           Calculates the likelihood probability for multiple
//                     Gaussian mixture components.
//
//  Parameters:
//    pMean            Pointer to the variance vector [height*step].
//    mMean            Pointer to the mean matrix [height][width].
//    pVal             Pointer to the input vector of additive values [height].
//    mVar             Pointer to the variance matrix [height][width].
//    pSrcDst          Pointer to the input and output vector of length [height].
//    step             The row step in pMean.
//    pSrc             Pointer to the input vector [width].
//    height           The number of rows in input matrices and the length of
//                     the result vector pSrcDst.
//    width            The length of the input matrices row and the vector pSrc.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc, pMean, pVar,
//                     pSrcDst, mMean, or mVar pointer is null.
//    ippStsSizeErr    Indicates an error when heightor width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
IPPAPI(IppStatus, ippsLogGaussAddMultiMix_LowScaled_16s32f_D2, (const Ipp16s* pMean,
       const Ipp16s* pVar, int step, const Ipp16s* pSrc, int width,
        const Ipp32f* pVal, Ipp32f* pSrcDst, int height, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussAddMultiMix_LowScaled_16s32f_D2L, (const Ipp16s** mMean,
       const Ipp16s** mVar, const Ipp16s* pSrc, int width, const Ipp32f* pVal,
       Ipp32f* pSrcDst, int height, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:              LogGaussMixture_*
//  Purpose:           Calculates the likelihood probability for the Gaussian mixture
//
//  Parameters:
//    pMean            Pointer to the variance vector [height*step].
//    mMean            Pointer to the mean matrix [height][width].
//    pVar             Pointer to the variance vector [height*step].
//    mVar             Pointer to the variance matrix [height][width].
//    pVal             Pointer to the weight constant vector [height]..
//    pSrc             Pointer to the input vector [width].
//    pResult          Pointer to the output mixture value.
//    step             The row step in pMean and pVar.
//    height           Number of Gaussian mixture components.
//    width            Length of the mean and variance matrices rows and pSrc vector.
//    scaleFactor
//
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the mMean, mVar, pMean, pVar, pVal or
//                     pResult pointer is null.
//    ippStsSizeErr    Indicates an error when height, step or width is less than or
//                     equal to 0.
//    ippStsStrideErr  Indicates an error when width > step.
//
*/
/*
//Case 1: Operation for the inverse diagonal covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussMixture_Scaled_16s32f_D2,(const Ipp16s* pSrc, const Ipp16s* pMean,
       const Ipp16s* pVar, int height, int step, int width, const Ipp32f* pVal,
       Ipp32f* pResult, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_Scaled_16s32f_D2L,(const Ipp16s* pSrc, const Ipp16s** mMean,
       const Ipp16s** mVar, int height, int width, const Ipp32f* pVal, Ipp32f* pResult,
       int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_LowScaled_16s32f_D2,(const Ipp16s* pSrc,
       const Ipp16s* pMean, const Ipp16s* pVar, int height, int step, int width,
       const Ipp32f* pVal, Ipp32f* pResult, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_LowScaled_16s32f_D2L,(const Ipp16s* pSrc,
       const Ipp16s** mMean, const Ipp16s** mVar, int height, int width,
       const Ipp32f* pVal, Ipp32f* pResult, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_32f_D2,(const Ipp32f* pSrc, const Ipp32f* pMean,
       const Ipp32f* pVar, int height, int step, int width, const Ipp32f* pVal,
       Ipp32f* pResult))

IPPAPI(IppStatus, ippsLogGaussMixture_32f_D2L,(const Ipp32f* pSrc, const Ipp32f** mMean,
       const Ipp32f** mVar, int height, int width, const Ipp32f* pVal, Ipp32f* pResult))

IPPAPI(IppStatus, ippsLogGaussMixture_64f_D2,(const Ipp64f* pSrc, const Ipp64f* pMean,
       const Ipp64f* pVar, int height, int step, int width, const Ipp64f* pVal,
       Ipp64f* pResult))

IPPAPI(IppStatus, ippsLogGaussMixture_64f_D2L,(const Ipp64f* pSrc, const Ipp64f** mMean,
       const Ipp64f** mVar, int height, int width, const Ipp64f* pVal, Ipp64f* pResult))

/*
//Case 2: Operation for the identity covariance matrix
*/
IPPAPI(IppStatus, ippsLogGaussMixture_IdVarScaled_16s32f_D2,(const Ipp16s* pSrc,
       const Ipp16s* pMean, int height, int step, int width, const Ipp32f* pVal,
       Ipp32f* pResult, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_IdVarScaled_16s32f_D2L,(const Ipp16s* pSrc,
       const Ipp16s** mMean, int height, int width, const Ipp32f* pVal,
       Ipp32f* pResult, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_IdVarLowScaled_16s32f_D2,(const Ipp16s* pSrc,
       const Ipp16s* pMean, int height, int step, int width, const Ipp32f* pVal,
       Ipp32f* pResult, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_IdVarLowScaled_16s32f_D2L,(const Ipp16s* pSrc,
       const Ipp16s** mMean, int height, int width, const Ipp32f* pVal,
       Ipp32f* pResult, int scaleFactor))

IPPAPI(IppStatus, ippsLogGaussMixture_IdVar_32f_D2,(const Ipp32f* pSrc,
       const Ipp32f* pMean, int height, int step, int width, const Ipp32f* pVal,
       Ipp32f* pResult))

IPPAPI(IppStatus, ippsLogGaussMixture_IdVar_32f_D2L,(const Ipp32f* pSrc,
       const Ipp32f** mMean, int height, int width, const Ipp32f* pVal,
       Ipp32f* pResult))

IPPAPI(IppStatus, ippsLogGaussMixture_IdVar_64f_D2,(const Ipp64f* pSrc,
       const Ipp64f* pMean, int height, int step, int width, const Ipp64f* pVal,
       Ipp64f* pResult))

IPPAPI(IppStatus, ippsLogGaussMixture_IdVar_64f_D2L,(const Ipp64f* pSrc,
       const Ipp64f** mMean, int height, int width, const Ipp64f* pVal,
       Ipp64f* pResult))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:              ippsLogSum_*
//  Purpose:           Logarithmically sums vector elements.
//  Parameters:
//    pSrc             The first input vector [len].
//    pResult          Pointer to the result value.
//    len              The number of elements in the input and output vectors.
//    hint             Recommends to use a specific code for the
//                     Logarithmically Sums.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when the pSrc or pResult pointer is null.
//    ippStsSizeErr    Indicates an error when len is less than or equal to 0.
//
*/
IPPAPI(IppStatus,ippsLogSum_64f,(const Ipp64f* pSrc, Ipp64f* pResult, int len,
                                 IppHintAlgorithm hint))

IPPAPI(IppStatus,ippsLogSum_32f,(const Ipp32f* pSrc, Ipp32f* pResult, int len,
                                 IppHintAlgorithm hint))

IPPAPI(IppStatus,ippsLogSum_32s_Sfs,(const Ipp32s* pSrc, Ipp32s* pResult, int len,
        int scaleFactor, IppHintAlgorithm hint))

IPPAPI(IppStatus,ippsLogSum_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pResult, int len,
        int scaleFactor, IppHintAlgorithm hint))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsWeightedMeanColumn_*_*
//  Purpose:        Computes the weighted mean values for the column elements.
//  Returns:
//                  ippStsNoErr        Indicates no error.
//                  ippStsNullPtrErr   Indicates an error when pSrc, mSrc, pWgt, or pDstMean pointer is null.
//                  ippStsSizeErr      Indicates an error when height or width is less than or equal to 0.
//                  IppStsStrideErr    Indicates an error when step is less than width.
//  Parameters:
//      pSrc          Pointer to the input vector [height*step].
//      mSrc          Pointer to the input matrix [height][width].
//      pWgt          Pointer to the weights vector [height].
//      height        Number of rows in the input matrix.
//      step          Row step in the input vector (measured in pSrc elements).
//      pDstMean      Pointer to the output mean vector [width].
//      width         Number of columns in the input matrix, and also the length of the output mean vector pDstMean.
//  Notes:
*/


IPPAPI(IppStatus, ippsWeightedMeanColumn_32f_D2,(const Ipp32f* pSrc, int step,
       const Ipp32f* pWgt, int height, Ipp32f* pDstMean, int width))
IPPAPI(IppStatus, ippsWeightedMeanColumn_32f_D2L,(const Ipp32f** mSrc,
       const Ipp32f* pWgt, int height, Ipp32f* pDstMean, int width))
IPPAPI(IppStatus, ippsWeightedMeanColumn_64f_D2,(const Ipp64f* pSrc, int step,
       const Ipp64f* pWgt, int height, Ipp64f* pDstMean, int width))
IPPAPI(IppStatus, ippsWeightedMeanColumn_64f_D2L,(const Ipp64f** mSrc,
       const Ipp64f* pWgt, int height, Ipp64f* pDstMean, int width))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsWeightedVarColumn_*_*
//  Purpose:        Computes the weighted variances values for the column elements.
//  Returns:
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when pSrc, mSrc, pWgt, pSrcMean,
//                            or pDstVar pointer is null.
//      ippStsSizeErr      Indicates an error when height or width is less than
//                            or equal to 0.
//      ippStsStrideErr    Indicates an error when step is less than width.
//  Parameters:
//      pSrc          Pointer to the input vector [height*step].
//      mSrc          Pointer to the input matrix [height][width].
//      pWgt          Pointer to the weights vector [height].
//      height        Number of rows in the input matrix.
//      step          Row step in the input vector (measured in pSrc elements).
//      pSrcMean      Pointer to the input mean vector [width].
//      pDstVar       Pointer to the output variance vector [width].
//      width         Number of columns in the input matrix, and also the length
//                    of the input mean vector pSrcMean and the output variance vector pDstVar.
*/


IPPAPI(IppStatus, ippsWeightedVarColumn_32f_D2,(const Ipp32f* pSrc, int step,
             const Ipp32f* pWgt, int height, const Ipp32f* pSrcMean,
             Ipp32f* pDstVar, int width))
IPPAPI(IppStatus, ippsWeightedVarColumn_32f_D2L,(const Ipp32f** mSrc,
             const Ipp32f* pWgt, int height, const Ipp32f* pSrcMean,
             Ipp32f* pDstVar, int width))
IPPAPI(IppStatus, ippsWeightedVarColumn_64f_D2,(const Ipp64f* pSrc, int step,
             const Ipp64f* pWgt, int height, const Ipp64f* pSrcMean,
             Ipp64f* pDstVar, int width))
IPPAPI(IppStatus, ippsWeightedVarColumn_64f_D2L,(const Ipp64f** mSrc,
              const Ipp64f* pWgt, int height, const Ipp64f* pSrcMean,
              Ipp64f* pDstVar,int width))



/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsWeightedMeanVarColumn_*_*
//  Purpose:        Computes the weighted mean  variances values for the column elements.
//  Returns:
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSrc, mSrc, pWgt, pDstMean,
//                        or pDstVar pointer is null.
//      ippStsSizeErr     Indicates an error when height or width is less than
//                        or equal to 0.
//      ippStsStrideErr   Indicates an error when step is less than width.
//  Parameters:
//      pSrc          Pointer to the input vector [height*step].
//      mSrc          Pointer to the input matrix [height][width].
//      pWgt          Pointer to the weights vector [height].
//      height        Number of rows in the input matrix.
//      step          Row step in the input vector (measured in pSrc elements).
//      pDstMean      Pointer to the output mean vector [width].
//      pDstVar       Pointer to the output variance vector [width].
//      width         Number of columns in the input matrix, and also the length of the output mean vector pSrcMean and the output variance vector pDstVar.
*/


IPPAPI(IppStatus, ippsWeightedMeanVarColumn_32f_D2,(const Ipp32f* pSrc, int step,
       const Ipp32f* pWgt, int height, Ipp32f* pDstMean, Ipp32f* pDstVar, int width))
IPPAPI(IppStatus, ippsWeightedMeanVarColumn_32f_D2L,(const Ipp32f** mSrc,
       const Ipp32f* pWgt, int height, Ipp32f* pDstMean, Ipp32f* pDstVar, int width))
IPPAPI(IppStatus, ippsWeightedMeanVarColumn_64f_D2,(const Ipp64f* pSrc, int step,
       const Ipp64f* pWgt, int height, Ipp64f* pDstMean, Ipp64f* pDstVar, int width))
IPPAPI(IppStatus, ippsWeightedMeanVarColumn_64f_D2L,(const Ipp64f** mSrc,
       const Ipp64f* pWgt, int height, Ipp64f* pDstMean, Ipp64f* pDstVar, int width))



/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsCrossCorrCoeffDecim
//  Purpose:        Calculate vector of cross correlation coefficients with decimation.
//  Returns:
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc1, pSrc2, or pDst pointer is null.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0.
//      ippStsBadArgErr    Indicates an error when val is less than 0.
//  Parameters:
//      pSrc1       Pointer to the first input vector [maxLen].
//      pSrc2       Pointer to the second input vector [maxLen].
//      pDst        Pointer to the output vector [(maxLen-minLen+dec-1)/dec].
//      maxLen      Maximal length of cross correlation.
//      minLen      Minimal length of cross correlation.
//      dec         Decimation step.
*/
IPPAPI(IppStatus, ippsCrossCorrCoeffDecim_16s32f,(const Ipp16s* pSrc1,
            const Ipp16s* pSrc2, int maxLen, int minLen, Ipp32f* pDst, int dec))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsCrossCorrCoeff
//  Purpose:        Calculate cross correlation coefficient.
//  Context:
//  Returns:
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc1, pSrc2, or pResult pointer is null.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0.
//      ippStsBadArgErr    Indicates an error when val is less than 0.
//  Parameters:
//      pSrc1        Pointer to the first input vector [len].
//      pSrc2        Pointer to the second input vector [len].
//      len          Length of the input vectors.
//      pResult      Pointer to the result cross correlation coefficient value.
//      val          First vector length value.
*/

IPPAPI(IppStatus, ippsCrossCorrCoeff_16s32f,(const Ipp16s* pSrc1,
                  const Ipp16s* pSrc2, int len, Ipp32f* pResult))
IPPAPI(IppStatus, ippsCrossCorrCoeffPartial_16s32f,(const Ipp16s* pSrc1,
                   const Ipp16s* pSrc2, int len, Ipp32f val, Ipp32f* pResult))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsCrossCorrCoeffInterpolation
//  Purpose:        Calculate cross correlation coefficient.
//  Context:
//  Returns:
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc1, pSrc2, pBeta or pResult pointer is null.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0.
//      ippStsStrideErr    Indicates an error when srcStep or dstStep is less than width.
// Parameters:
//      pSrc1        Pointer to the first input vector [len].
//      pSrc2        Pointer to the second input vector [len+1].
//      len          Length of the input vectors.
//      pResult      Pointer to the result cross correlation coefficient value.
//      pBeta        Pointer to the result value of fractional part of the pitch period.
*/

IPPAPI(IppStatus, ippsCrossCorrCoeffInterpolation_16s32f,(const Ipp16s* pSrc1,
                  const Ipp16s* pSrc2, int len, Ipp32f* pBeta, Ipp32f* pResult))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsBuildSignTable_8u1u
//  Purpose:        Fills sign table for Gaussian mixture calculation.
//
//  Parameters:
//    pIndx            Pointer to the cluster indexes vector ([frames*num] or sum of pNum elements).
//    num              Number of clusters for each input vector.
//    mShortlist       Pointer to the shortlist matrix [clust*width] (in bytes).
//    clust            Number of rows in shortlist vector (equal to the codebook size).
//    width            Row length in shortlist matrix in bytes.
//    shift            First element displacement in shortlist vector rows (in bits).
//    pSign            Pointer to the output vector of Gaussian calculation
//                       signs [frames*(comps+7)/8] (in bytes).
//    frames           Number of input vectors (rows in pSign vector).
//    comps            Number of Gaussian mixture components (bit columns in pSign vector).
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pIndx, pSign, mShortlist or pNum is NULL.
//    ippStsSizeErr    Indicates an error when clust, width, frames, comps, num or one
//                       of pNum vector elements is less than or equal to 0 or when
//                       shift is less than 0.
//    ippStsStrideErr  Indicates an error when width is less than (shift+height+7)/8.
//    ippStsBadArgErr  Indicates an error when one of pIndx vector elements is
//                       less than 0 or greater than or equal to clust.
//  Notes:
*/

IPPAPI(IppStatus, ippsBuildSignTable_8u1u, (const Ipp32s* pIndx, int num, const Ipp8u** mShortlist,
                   int clust, int width, int shift, Ipp8u* pSign, int frames, int comps))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsBuildSignTable_Var_8u1u
//  Purpose:        Fills sign table for Gaussian mixture calculation.
//
//  Parameters:
//    pIndx            Pointer to the cluster indexes vector ([frames*num] or sum of pNum elements).
//    pNum             Number of clusters vector [frames].
//    mShortlist       Pointer to the shortlist matrix [clust*width] (in bytes).
//    clust            Number of rows in shortlist vector (equal to the codebook size).
//    width            Row length in shortlist matrix in bytes.
//    shift            First element displacement in shortlist vector rows (in bits).
//    pSign            Pointer to the output vector of Gaussian calculation
//                       signs [frames*(comps+7)/8] (in bytes).
//    frames           Number of input vectors (rows in pSign vector).
//    comps            Number of Gaussian mixture components (bit columns in pSign vector).
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pIndx, pSign, mShortlist or pNum is NULL.
//    ippStsSizeErr    Indicates an error when clust, width, frames, comps, num or one
//                       of pNum vector elements is less than or equal to 0 or when
//                       shift is less than 0.
//    ippStsStrideErr  Indicates an error when width is less than (shift+height+7)/8.
//    ippStsBadArgErr  Indicates an error when one of pIndx vector elements is
//                       less than 0 or greater than or equal to clust.
//  Notes:
*/

IPPAPI(IppStatus, ippsBuildSignTable_Var_8u1u, (const Ipp32s* pIndx, const int* pNum,
                 const Ipp8u** mShortlist, int clust, int width, int shift, Ipp8u* pSign,
                 int frames, int comps))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsLogGaussMixture_Select*_*_D2
//  Purpose:        Calculates the likelihood probability for the Gaussian
//                   mixture using Gaussian selection.
//
//  Parameters:
//    pSrc             Pointer to the input vector
//    pMean            Pointer to the mean vector
//    pVar             Pointer to the variance vector
//    step             Row step in mean, variance and input vectors (in pMean elements)
//    width            Length of the mean, variance and input matrix rows
//    pVal             Pointer to the vector of weight constants
//    pSign            Pointer to the vector of Gaussian calculation
//                         signs [frames*(height+7)/8] (in bytes).
//    height           Number of Gaussian mixture components
//    pResult          Pointer to the vector of output mixture values
//    frames           Number of input vectors; also the length of pSign row
//    none             Result value if no Gaussian is calculated
//    scaleFactor      Scaling factor for intermediate sums.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pSrc, pMean, pVar, pSign, pVal
//                      or pResult is NULL.
//    ippStsSizeErr    Indicates an error when width, height or frames less than
//                      or equal to 0.
//    ippStsStrideErr  Indicates an error when step is less than width.
//    ippStsSizeErr    Indicates an error when width, height, frames less than
//                      or equal to 0
//    ippStsStrideErr  Indicates an error when step is less than width .
//    ippStsNoGaussian Indicates a warning when no Gaussian is calculated for
//                      one of input vectors.
//  Notes:
*/

IPPAPI(IppStatus, ippsLogGaussMixture_Select_32f_D2, (const Ipp32f* pSrc, const Ipp32f* pMean,
            const Ipp32f* pVar,/* const Ipp32f* Det,*/ int step, int width, const Ipp32f* pVal,
            const Ipp8u* pSign, int height, Ipp32f* pResult, int frames, Ipp32f none))

IPPAPI(IppStatus, ippsLogGaussMixture_SelectScaled_16s32f_D2, (const Ipp16s* pSrc,
            const Ipp16s* pMean, const Ipp16s* pVar, int step, int width, const Ipp32f* pVal,
            const Ipp8u* pSign, int height, Ipp32f* pResult, int frames, Ipp32f none, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsLogGaussMixture_Select*_*_D2L
//  Purpose:        Calculates the likelihood probability for the Gaussian
//                   mixture using Gaussian selection.
//
//  Parameters:
//    mSrc             Pointer to the input matrix [frames][width].
//    mMean            Pointer to the mean matrix [height][width].
//    mVar             Pointer to the variance matrix [height][width].
//    width            Length of the mean, variance and input matrix rows
//    pVal             Pointer to the vector of weight constants
//    pSign            Pointer to the vector of Gaussian calculation
//                         signs [frames*(height+7)/8] (in bytes).
//    height           Number of Gaussian mixture components
//    pResult          Pointer to the vector of output mixture values
//    frames           Number of input vectors; also the length of pSign row
//    none             Result value if no Gaussian is calculated
//    scaleFactor      Scaling factor for intermediate sums.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when mSrc, mMean, mVar, pSign, pVal
//                      or pResult is NULL.
//    ippStsSizeErr    Indicates an error when width, height or frames less than
//                      or equal to 0.
//    ippStsSizeErr    Indicates an error when width, height, frames less than
//                      or equal to 0
//    ippStsNoGaussian Indicates a warning when no Gaussian is calculated for
//                      one of input vectors.
//  Notes:
*/

IPPAPI(IppStatus, ippsLogGaussMixture_Select_32f_D2L,(const Ipp32f** mSrc, const Ipp32f** mMean,
       const Ipp32f** mVar, int width, const Ipp32f* pVal, const Ipp8u* pSign, int height,
       Ipp32f* pResult, int frames, Ipp32f none))

IPPAPI(IppStatus, ippsLogGaussMixture_SelectScaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s** mMean, const Ipp16s** mVar, int width, const Ipp32f* pVal,
       const Ipp8u* pSign, int height, Ipp32f* pResult, int frames, Ipp32f none, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsLogGaussMixture_SelectIdVar*_*_D2
//  Purpose:        Calculates the likelihood probability for the Gaussian
//                   mixture using Gaussian selection.
//
//  Parameters:
//    pSrc             Pointer to the input vector
//    pMean            Pointer to the mean vector
//    step             Row step in mean, variance and input vectors (in pMean elements)
//    width            Length of the mean, variance and input matrix rows
//    pVal             Pointer to the vector of weight constants
//    pSign            Pointer to the vector of Gaussian calculation
//                         signs [frames*(height+7)/8] (in bytes).
//    height           Number of Gaussian mixture components
//    pResult          Pointer to the vector of output mixture values
//    frames           Number of input vectors; also the length of pSign row
//    none             Result value if no Gaussian is calculated
//    scaleFactor      Scaling factor for intermediate sums.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when pSrc, pMean, pSign, pVal
//                      or pResult is NULL.
//    ippStsSizeErr    Indicates an error when width, height or frames less than
//                      or equal to 0.
//    ippStsStrideErr  Indicates an error when step is less than width.
//    ippStsSizeErr    Indicates an error when width, height, frames less than
//                      or equal to 0
//    ippStsStrideErr  Indicates an error when step is less than width .
//    ippStsNoGaussian Indicates a warning when no Gaussian is calculated for
//                      one of input vectors.
//  Notes:
*/

IPPAPI(IppStatus, ippsLogGaussMixture_SelectIdVar_32f_D2, (const Ipp32f* pSrc, const Ipp32f* pMean,
       int step, int width, const Ipp32f* pVal, const Ipp8u* pSign, int height, Ipp32f* pResult,
       int frames, Ipp32f none))

IPPAPI(IppStatus, ippsLogGaussMixture_SelectIdVarScaled_16s32f_D2, (const Ipp16s* pSrc,
       const Ipp16s* pMean, int step, int width, const Ipp32f* pVal, const Ipp8u* pSign, int height,
       Ipp32f* pResult, int frames, Ipp32f none, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsLogGaussMixture_SelectIdVar*_*_D2L
//  Purpose:        Calculates the likelihood probability for the Gaussian
//                   mixture using Gaussian selection.
//
//  Parameters:
//    mSrc             Pointer to the input matrix [frames][width].
//    mMean            Pointer to the mean matrix [height][width].
//    width            Length of the mean, variance and input matrix rows
//    pVal             Pointer to the vector of weight constants
//    pSign            Pointer to the vector of Gaussian calculation
//                         signs [frames*(height+7)/8] (in bytes).
//    height           Number of Gaussian mixture components
//    pResult          Pointer to the vector of output mixture values
//    frames           Number of input vectors; also the length of pSign row
//    none             Result value if no Gaussian is calculated
//    scaleFactor      Scaling factor for intermediate sums.
//  Return:
//    ippStsNoErr      Indicates no error.
//    ippStsNullPtrErr Indicates an error when mSrc, mMean, pSign, pVal
//                      or pResult is NULL.
//    ippStsSizeErr    Indicates an error when width, height or frames less than
//                      or equal to 0.
//    ippStsSizeErr    Indicates an error when width, height, frames less than
//                      or equal to 0
//    ippStsNoGaussian Indicates a warning when no Gaussian is calculated for
//                      one of input vectors.
//  Notes:
*/

IPPAPI(IppStatus, ippsLogGaussMixture_SelectIdVar_32f_D2L, (const Ipp32f** mSrc,
       const Ipp32f** mMean, int width, const Ipp32f* pVal, const Ipp8u* pSign, int height,
       Ipp32f* pResult, int frames, Ipp32f none))

IPPAPI(IppStatus, ippsLogGaussMixture_SelectIdVarScaled_16s32f_D2L, (const Ipp16s** mSrc,
       const Ipp16s** mMean, int width, const Ipp32f* pVal, const Ipp8u* pSign, int height,
       Ipp32f* pResult, int frames, Ipp32f none, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVQSingle_Thresh_*
//  Purpose:        Quantizes the input vector given a codebook getting
//                   several closest clusters
//
//  Parameters:
//    pSrc             Pointer to the input vector
//    pIndx            Pointer to the destination indexes vector
//    pCdbk            Pointer to the codebook structure
//    val              Relative threshold value
//    pNum             Pointer to the number of clusters within threshold [1]
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pSrc, pIndx, pCdbk or pNum is NULL
//    ippStsBadArgErr  Indicates an error when val is less than 1
//  Notes:
*/

IPPAPI(IppStatus, ippsVQSingle_Thresh_32f,(const Ipp32f *pSrc, Ipp32s *pIndx, const IppsCdbkState_32f* pCdbk, Ipp32f val, int *pNum))

IPPAPI(IppStatus, ippsVQSingle_Thresh_16s,(const Ipp16s *pSrc, Ipp32s *pIndx, const IppsCdbkState_16s* pCdbk, Ipp32f val, int *pNum))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVQDistSingle_Thresh_*
//  Purpose:        Quantizes the input vector given a codebook getting
//                   several closest clusters
//
//  Parameters:
//    pSrc             Pointer to the input vector
//    pIndx            Pointer to the destination indexes vector
//    pDist            Pointer to the destination distances vector
//    pCdbk            Pointer to the codebook structure
//    val              Relative threshold value
//    pNum             Pointer to the number of clusters within threshold [1]
//    scaleFactor      Refer to "Integer Scaling" in Chapter 2.
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pSrc, pIndx, pDist, pCdbk or pNum is NULL
//    ippStsBadArgErr  Indicates an error when val is less than 1
//  Notes:
*/

IPPAPI(IppStatus, ippsVQDistSingle_Thresh_32f,(const Ipp32f *pSrc, Ipp32s *pIndx, Ipp32f *pDist, const IppsCdbkState_32f* pCdbk, Ipp32f val, int *pNum))

IPPAPI(IppStatus, ippsVQDistSingle_Thresh_16s32s_Sfs,(const Ipp16s *pSrc, Ipp32s *pIndx, Ipp32s *pDist, const IppsCdbkState_16s* pCdbk, Ipp32f val, int *pNum, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVQSingle_Sort_*
//  Purpose:        Quantizes the input vector given a codebook getting
//                   several closest clusters
//
//  Parameters:
//    pSrc             Pointer to the input vector
//    pIndx            Pointer to the destination indexes vector
//    pCdbk            Pointer to the codebook structure
//    num              Number of closest clusters to search for each input vector
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pSrc, pIndx, pCdbk is NULL
//    ippStsSizeErr    Indicates an error when num less than or equal to 0 or
//                      is greater than the codebook size.
//  Notes:
*/

IPPAPI(IppStatus, ippsVQSingle_Sort_32f,(const Ipp32f *pSrc, Ipp32s *pIndx, const IppsCdbkState_32f* pCdbk, int num))

IPPAPI(IppStatus, ippsVQSingle_Sort_16s,(const Ipp16s *pSrc, Ipp32s *pIndx, const IppsCdbkState_16s* pCdbk, int num))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVQDistSingle_Sort_*
//  Purpose:        Quantizes the input vector given a codebook getting
//                   several closest clusters
//
//  Parameters:
//    pSrc             Pointer to the input vector
//    pIndx            Pointer to the destination indexes vector
//    pDist            Pointer to the destination distances vector
//    pCdbk            Pointer to the codebook structure
//    num              Number of closest clusters to search for each input vector
//    scaleFactor      Refer to "Integer Scaling" in Chapter 2.
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pSrc, pIndx, pDist, pCdbk is NULL
//    ippStsSizeErr    Indicates an error when num less than or equal to 0 or
//                      is greater than the codebook size.
//  Notes:
*/

IPPAPI(IppStatus, ippsVQDistSingle_Sort_32f,(const Ipp32f *pSrc, Ipp32s *pIndx, Ipp32f *pDist, const IppsCdbkState_32f* pCdbk, int num))

IPPAPI(IppStatus, ippsVQDistSingle_Sort_16s32s_Sfs,(const Ipp16s *pSrc, Ipp32s *pIndx, Ipp32s *pDist, const IppsCdbkState_16s* pCdbk, int num, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsFillShortlist_Row_1u
//  Purpose:        Fills row-wise shortlist table for Gaussian selection.
//                   several closest clusters
//
//  Parameters:
//    pIndx            Pointer to the cluster indexes vector ([num*clust])
//    num              Number of Gaussian for each codebook cluster
//    pShortlist       Pointer to the shortlist matrix [clust][Listlen] (size in bytes)
//    clust            Number of rows in shortlist vector and rows in pIndx
//    Listlen          Number of elements in shortlist vector
//    shift            First element displacement in shortlist vector rows (in bits)
//    height           Number of Gaussian mixture components
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pIndx or pShortlist NULL
//    ippStsSizeErr    Indicates an error when clust, height, Listlen, num vector elements
//                      is less than or equal to 0 or when shift is less than 0
//    ippStsStrideErr  Indicates an error when Listlen is less than (shift+height+7)/8.
//    ippStsBadArgErr  Indicates an error when one of pIndx vector elements is less than
//                      0 or greater than or equal to height.
//  Notes:
*/

IPPAPI(IppStatus, ippsFillShortlist_Row_1u,(const Ipp32s* pIndx, int height, int num, Ipp8u** pShortlist, int clust, int Listlen, int shift))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsFillShortlist_RowVar_1u
//  Purpose:        Fills row-wise shortlist table for Gaussian selection.
//                   several closest clusters
//
//  Parameters:
//    pIndx            Pointer to the cluster indexes vector ([sum of pNum's])
//    pNum             Number of clusters vector [clust].
//    pShortlist       Pointer to the shortlist matrix [clust][Listlen] (size in bytes)
//    clust            Number of rows in shortlist vector and rows in pIndx
//    Listlen          Number of elements in shortlist vector
//    shift            First element displacement in shortlist vector rows (in bits)
//    height           Number of Gaussian mixture components
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pIndx or pShortlist NULL
//    ippStsSizeErr    Indicates an error when clust, height, Listlen, or any pNum elements
//                      is less than or equal to 0 or when shift is less than 0.
//    ippStsStrideErr  Indicates an error when Listlen is less than (shift+height+7)/8.
//    ippStsBadArgErr  Indicates an error when one of pIndx vector elements is less than
//                      0 or greater than or equal to height.
//  Notes:
*/

IPPAPI(IppStatus, ippsFillShortlist_RowVar_1u,(const Ipp32s* pIndx, int *pNum, int height, Ipp8u** pShortlist, int clust, int Listlen, int shift))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsFillShortlist_Column_1u
//  Purpose:        Fills column-wise shortlist table for Gaussian selection.
//                   several closest clusters
//
//  Parameters:
//    pIndx            Pointer to the cluster indexes vector ([num*height])
//    num              Number of Gaussian for each codebook cluster
//    pShortlist       Pointer to the shortlist matrix [clust][Listlen] (size in bytes)
//    clust            Number of rows in shortlist vector
//    Listlen          Number of elements in shortlist vector
//    shift            First element displacement in shortlist vector rows (in bits)
//    height           Number of Gaussian mixture components (and rows in pIndx)
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pIndx or pShortlist NULL
//    ippStsSizeErr    Indicates an error when clust, height, Listlen, num vector elements
//                      is less than or equal to 0 or when shift is less than 0
//    ippStsStrideErr  Indicates an error when Listlen is less than (shift+height+7)/8.
//    ippStsBadArgErr  Indicates an error when one of pIndx vector elements is less than
//                      0 or greater than or equal to clust.
//  Notes:
*/

IPPAPI(IppStatus, ippsFillShortlist_Column_1u,(const Ipp32s* pIndx, int num, Ipp8u** pShortlist, int clust, int Listlen, int shift, int height))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsFillShortlist_ColumnVar_1u
//  Purpose:        Fills column-wise shortlist table for Gaussian selection.
//                   several closest clusters
//
//  Parameters:
//    pIndx            Pointer to the cluster indexes vector ([sum of pNum's])
//    pNum             Number of clusters vector [height].
//    pShortlist       Pointer to the shortlist matrix [clust][Listlen] (size in bytes)
//    clust            Number of rows in shortlist vector
//    Listlen          Number of elements in shortlist vector
//    shift            First element displacement in shortlist vector rows (in bits)
//    height           Number of Gaussian mixture components (and rows in pIndx)
//  Return:
//    ippStsNoErr      Indicates no error
//    ippStsNullPtrErr Indicates an error when pIndx or pShortlist NULL
//    ippStsSizeErr    Indicates an error when clust, height, Listlen, any pNum elements
//                      is less than or equal to 0 or when shift is less than 0.
//    ippStsStrideErr  Indicates an error when Listlen is less than (shift+height+7)/8.
//    ippStsBadArgErr  Indicates an error when one of pIndx vector elements is less than
//                      0 or greater than or equal to clust.
//  Notes:
*/

IPPAPI(IppStatus, ippsFillShortlist_ColumnVar_1u,(const Ipp32s* pIndx, int *pNum, Ipp8u** pShortlist, int clust, int ListLen, int shift, int height))



/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsTabsCalculation_Aurora
//  Purpose:        Calculates filter coefficients for residual filter
//
//
//   Arguments:
//      pSrc           Pointer to the input vector [10]
//      pDst           Pointer to the output vector [17]
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc or pDst pointer is null.
*/

IPPAPI(IppStatus,  ippsTabsCalculation_Aurora_32f,(const Ipp32f *pSrc,Ipp32f *pDst))

IPPAPI(IppStatus,  ippsTabsCalculation_Aurora_16s,(const Ipp16s *pSrc,Ipp16s *pDst))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResidualFilter_Aurora
//  Purpose:        Calculates denoised waveform signal
//   Arguments:
//      pTabs          Pointer to the input vector [17]
//      pSrc           Pointer to the input vector [96]
//      pDst           Pointer to the output vector [80]
//      scaleFactor    Refer to "Integer Scaling" in Chapter 2.
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc or pDst or pTabs pointer is null.
*/

IPPAPI(IppStatus,  ippsResidualFilter_Aurora_32f,(const Ipp32f* pSrc, Ipp32f* pDst, const Ipp32f* pTabs))

IPPAPI(IppStatus,  ippsResidualFilter_Aurora_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst, const Ipp16s* pTabs, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsWaveProcessing_Aurora
//  Purpose:        Processes waveform data after noise reduction
//   Arguments:
//      pSrc           Pointer to the input vector [200]
//      pDst           Pointer to the output vector [200]
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc or pDst pointer is null.
*/

IPPAPI(IppStatus,  ippsWaveProcessing_Aurora_32f,(const Ipp32f *pSrc,Ipp32f *pDst))

IPPAPI(IppStatus,  ippsWaveProcessing_Aurora_16s,(const Ipp16s *pSrc,Ipp16s *pDst))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsSmoothedPowerSpectrumAurora
//  Purpose:        Calculates smoothed magnitude of FFT output
//   Arguments:
//      pSrc           Pointer to the input vector [len]
//      pDst           Pointer to the output vector [len/4+1]
//      len            The length of input and output vectors
//      scaleFactor    Refer to "Integer Scaling" in Chapter 2.
//   Return Value
//      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, or len is not multiple of 4
*/

IPPAPI(IppStatus,  ippsSmoothedPowerSpectrumAurora_32f,(Ipp32f *pSrc, Ipp32f *pDst,Ipp32s len))

IPPAPI(IppStatus,  ippsSmoothedPowerSpectrumAurora_32s_Sfs,(Ipp32s *pSrc, Ipp32s *pDst,Ipp32s len,
       int scaleFactor))

IPPAPI(IppStatus,  ippsSmoothedPowerSpectrumAurora_32s64s_Sfs,(Ipp32s *pSrc, Ipp64s *pDst,
       Ipp32s len, int scaleFactor))

IPPAPI(IppStatus,  ippsSmoothedPowerSpectrumAurora_16s,(Ipp16s *pSrc, Ipp16s *pDst,Ipp32s len))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsLowHighFilter_Aurora
//  Purpose:        Calculates low band and high band filters
//   Arguments:
//      pTabs          Pointer to the input vector [tapsLen]
//      tapsLen        The filter taps number (even)
//      pSrc           Pointer to the input vector [len+tapsLen-1]
//      pDstLow        Pointer to the output vector [len/2]
//      pDstHigh       Pointer to the output vector [len/2]
//      len            The input samples number (even)
//      scaleFactor    Refer to "Integer Scaling" in Chapter 2.
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc or pTabs or pDstLow or pDstHigh pointer is null.
//      ippStsSizeErr      Indicates an error when len or tapsLen is less than or equal to 0
*/

IPPAPI(IppStatus,  ippsLowHighFilter_Aurora_32f,(const Ipp32f* pSrc,
       Ipp32f* pDstLow, Ipp32f* pDstHigh, Ipp32s len, const Ipp32f* pTabs, Ipp32s tapsLen))

IPPAPI(IppStatus,  ippsLowHighFilter_Aurora_16s_Sfs,(const Ipp16s* pSrc,
       Ipp16s* pDstLow, Ipp16s* pDstHigh, Ipp32s len, const Ipp16s* pTabs, Ipp32s tapsLen, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsNoiseSpectrumUpdate_Aurora
//  Purpose:        Updates noise spectrum
//   Arguments:
//      pSrc           Pointer to the input vector of mean  [len]
//      pSrcNoise      Pointer to the input vector of noiseless signal spectrum  [len]
//      pDst           Pointer to the output vector [len]
//      len            The length of input and output vectors
//      ScaleFactor    Refer to "Integer Scaling" in Chapter 2.
//
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc, pSrcNoise, pDst pointer is null.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0
*/

IPPAPI(IppStatus,  ippsNoiseSpectrumUpdate_Aurora_32f,(const Ipp32f* pSrc, const Ipp32f* pSrcNoise,
       Ipp32f *pDst, int len))

IPPAPI(IppStatus,  ippsNoiseSpectrumUpdate_Aurora_16s_Sfs,(const Ipp16s* pSrc, const Ipp16s* pSrcNoise,
       Ipp16s *pDst, int len, int ScaleFactor))

IPPAPI(IppStatus,  ippsNoiseSpectrumUpdate_Aurora_32s_Sfs,(const Ipp32s* pSrc, const Ipp32s* pSrcNoise,
       Ipp32s *pDst, int len, int ScaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsWienerFilterDesign_Aurora
//  Purpose:        Calculates improved transfer function of adaptive Wiener filter
//   Arguments:
//      pSrc           Pointer to the input vector of square roots of power spectral density mean  [len]
//      pNoise         Pointer to the input vector of square roots of noise spectrum estimate  [len]
//      pDen           Pointer to the input vector of square roots of previous noiseless signal spectrum [len]
//      pDst           Pointer to the output vector [len]
//      len            The length of input and output vectors
//
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc, pNoise, pDen, pDst pointer is null.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0
*/

IPPAPI(IppStatus,  ippsWienerFilterDesign_Aurora_32f,(const Ipp32f* pSrc, const Ipp32f* pNoise,
       const Ipp32f* pDen, Ipp32f* pDst, int len))

IPPAPI(IppStatus,  ippsWienerFilterDesign_Aurora_16s,(const Ipp16s* pSrc, const Ipp16s* pNoise,
       const Ipp16s* pDen, Ipp16s* pDst, int len))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsBlindEqualization_Aurora
//  Purpose:        Equalizes the cepstral coefficients
//   Arguments:
//      pRefs          Pointer to the input vector of reference cepstrum  [len]
//      pCeps          Pointer to the input and output vector of cepstrum [len]
//      pBias          Pointer to the input and output vector of bias  [len]
//      len            The length of input and output vectors
//      val            The log energy value
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pRefs, pCeps, pBias pointer is null.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0
*/

IPPAPI(IppStatus,  ippsBlindEqualization_Aurora_32f,(const Ipp32f* pRefs, Ipp32f* pCeps, Ipp32f* pBias,
       int len, Ipp32f val))
IPPAPI(IppStatus,  ippsBlindEqualization_Aurora_16s,(const Ipp16s* pRefsQ6, Ipp16s* pCeps,
       Ipp16s* pBias, int len, Ipp32s valQ6))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsHighBandCoding_Aurora
//  Purpose:        Codes and decodes high frequency band energy values
//   Arguments:
//      pSrcHFB       Pointer to the input high frequency band energy vector [3].
//      pInSWP        Pointer to the input signal smoothed power spectrum vector [65].
//      pDSWP         Pointer to the denoised signal power spectrum vector [129].
//      pDstHFB       Pointer to the output coded high frequency band log energy vector [3].
//      scaleFactor   Refer to "Integer Scaling" in Chapter 2.
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pRefs, pCeps, pBias pointer is null.
//      ippBadArg          Indicates an error when a non-positive or NaN argument of logarithm is detected
*/

IPPAPI(IppStatus,  ippsHighBandCoding_Aurora_32f,(const Ipp32f* pSrcHFB,
       const Ipp32f* pInSWP, const Ipp32f* pDSWP, Ipp32f* pDstHFB))
IPPAPI(IppStatus,  ippsHighBandCoding_Aurora_32s_Sfs,(const Ipp32s* pSrcHFB,
       const Ipp32s* pInSWP, const Ipp32s* pDSWP, Ipp32s* pDstHFB, int scaleFactor))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsMatVecMul
//  Purpose:        Multiplies matrix by vector
//   Arguments:
//      pSrc      Pointer to the input vector [width].
//      pMatr     Pointer to the input matrix [height*step].
//      mMatr     Pointer to the input matrix [height][width].
//      step      Row step in pMatr vector (in pMatr elements).
//      width     Length of the input vector and input matrix rows
//      height    Number of rows in the input matrix and the length of the result vector.
//
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc, pMatr, mMatr pointer is null.
//      ippStsSizeErr      Indicates an error when width or height is less than or equal to 0
*/

IPPAPI(IppStatus,  ippsMatVecMul_16s_D2Sfs,(const Ipp16s* pMatr, int step, const Ipp16s* pSrc, int width,
       Ipp16s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus,  ippsMatVecMul_16s32s_D2Sfs,(const Ipp16s* pMatr, int step, const Ipp16s* pSrc, int width,
       Ipp32s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus,  ippsMatVecMul_32s_D2Sfs,(const Ipp32s* pMatr, int step, const Ipp32s* pSrc, int width,
       Ipp32s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus,  ippsMatVecMul_32f_D2,(const Ipp32f* pMatr, int step, const Ipp32f* pSrc, int width,
       Ipp32f* pDst, int height))

IPPAPI(IppStatus,  ippsMatVecMul_16s_D2LSfs,(const Ipp16s** mMatr, const Ipp16s* pSrc, int width,
       Ipp16s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus,  ippsMatVecMul_16s32s_D2LSfs,(const Ipp16s** mMatr, const Ipp16s* pSrc, int width,
       Ipp32s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus,  ippsMatVecMul_32s_D2LSfs,(const Ipp32s** mMatr, const Ipp32s* pSrc, int width,
       Ipp32s* pDst, int height, int scaleFactor))

IPPAPI(IppStatus,  ippsMatVecMul_32f_D2L,(const Ipp32f** mMatr, const Ipp32f* pSrc, int width,
       Ipp32f* pDst, int height))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVecMatMul
//  Purpose:        Multiplies vector by matrix
//   Arguments:
//      pSrc      Pointer to the input vector [height].
//      pMatr     Pointer to the input matrix [height*step].
//      mMatr     Pointer to the input matrix [height][width].
//      step      Row step in pMatr vector (in pMatr elements).
//      width     Length of the input vector and input matrix rows
//      height    Number of rows in the input matrix and the length of the result vector.
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSrc, pMatr, mMatr pointer is null.
//      ippStsSizeErr      Indicates an error when width or height is less than or equal to 0
*/
IPPAPI(IppStatus,  ippsVecMatMul_16s_D2Sfs,(const Ipp16s* pSrc, const Ipp16s* pMatr, int step, int height,
       Ipp16s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus,  ippsVecMatMul_16s32s_D2Sfs,(const Ipp16s* pSrc, const Ipp16s* pMatr, int step, int height,
       Ipp32s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus,  ippsVecMatMul_32s_D2Sfs,(const Ipp32s* pSrc, const Ipp32s* pMatr, int step, int height,
       Ipp32s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus,  ippsVecMatMul_32f_D2,(const Ipp32f* pSrc, const Ipp32f* pMatr, int step, int height,
       Ipp32f* pDst, int width))

IPPAPI(IppStatus,  ippsVecMatMul_16s_D2LSfs,(const Ipp16s* pSrc, const Ipp16s** mMatr, int height,
       Ipp16s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus,  ippsVecMatMul_16s32s_D2LSfs,(const Ipp16s* pSrc, const Ipp16s** mMatr, int height,
       Ipp32s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus,  ippsVecMatMul_32s_D2LSfs,(const Ipp32s* pSrc, const Ipp32s** mMatr, int height,
       Ipp32s* pDst, int width, int scaleFactor))

IPPAPI(IppStatus,  ippsVecMatMul_32f_D2L,(const Ipp32f* pSrc, const Ipp32f** mMatr, int height,
       Ipp32f* pDst, int width))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVADGetBufSize_Aurora
//  Purpose:        Queries the memory size for VAD decision
//   Arguments:
//      pSize           Pointer to the output value of the memory size needed for VAD decision
//
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSize  pointer is null.
*/

IPPAPI(IppStatus,  ippsVADGetBufSize_Aurora_32f,(Ipp32s* pSize))
IPPAPI(IppStatus,  ippsVADGetBufSize_Aurora_16s,(Ipp32s* pSize))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVADInit_Aurora
//  Purpose:        Initializes VAD decision process
//   Arguments:
//      pVADmem           Pointer to the VAD decision memory
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pVADmem  pointer is null.
*/

IPPAPI(IppStatus,  ippsVADInit_Aurora_32f,(Ipp8u* pVADmem))
IPPAPI(IppStatus,  ippsVADInit_Aurora_16s,(Ipp8u* pVADmem))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVADDecision_Aurora
//  Purpose:        Takes VAD decision for the input data
//   Arguments:
//      pCoeff        Pointer to the input vector of Mel-warped Wiener filter coefficients [25].
//      pTrans        Pointer to the input vector of Wiener filter transfer function [64].
//      nbSpeechFrame Speech frame hangover counter
//      res           VAD decision (1 for if voice detected, 0 otherwise).
//      pVADmem       Pointer to the VAD decision memory
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pVADmem  pointer is null.
*/

IPPAPI(IppStatus,  ippsVADDecision_Aurora_32f,(const Ipp32f* pCoeff, const Ipp32f* pTrans,
       int nbSpeechFrame, IppVADDecision_Aurora *pRes, Ipp8u* pVADmem))
IPPAPI(IppStatus,  ippsVADDecision_Aurora_16s,(const Ipp16s* pCoeff, const Ipp16s* pTrans,
       int nbSpeechFrame, IppVADDecision_Aurora *pRes, Ipp8u* pVADmem))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsVADFlush_Aurora
//  Purpose:        Takes VAD decision for the input data
//   Arguments:
//      pRes        VAD decision (1 for if voice detected, 0 otherwise).
//      pVADmem     Pointer to the VAD decision memory
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pVADmem, pRes pointer is null.
*/

IPPAPI(IppStatus,  ippsVADFlush_Aurora_32f,(IppVADDecision_Aurora *pRes, Ipp8u* pVADmem))
IPPAPI(IppStatus,  ippsVADFlush_Aurora_16s,(IppVADDecision_Aurora *pRes, Ipp8u* pVADmem))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseFree
//  Purpose:        Free structure for data resampling
//   Arguments:
//      pSpec          The pointer to the resampling state structure
//
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when the pSpec pointer is null.
*/

IPPAPI(IppStatus, ippsResamplePolyphaseFree_16s,(IppsResamplingPolyphase_16s* pSpec))

IPPAPI(IppStatus, ippsResamplePolyphaseFree_32f,(IppsResamplingPolyphase_32f* pSpec))

IPPAPI(IppStatus, ippsResamplePolyphaseFixedFree_16s,(IppsResamplingPolyphaseFixed_16s* pSpec))

IPPAPI(IppStatus, ippsResamplePolyphaseFixedFree_32f,(IppsResamplingPolyphaseFixed_32f* pSpec))



/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseInitAlloc
//  Purpose:        Initialize structure for data resampling
//   Arguments:
//      pSpec          The pointer to the resampling state structure
//      window         The size of the ideal lowpass filter window.
//      nStep          The discretization step for filter coefficients
//      rollf          The roll-off frequency of the filter.
//      alpha          The parameter of the Kaiser window.
//      width          Length of the input vector and input matrix rows
//      inRate         The input rate for resampling with fixed factor.
//      outRate        The output rate for resampling with fixed factor.
//      len            The filter length for resampling with fixed factor.
//      pSpec          The pointer to the resampling state structure to be created.
//      hint           Suggests using specific code. The values for the hint argument are described in "Flag and Hint Arguments"
//
//
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSpec is NULL.
//      ippStsSizeErr     Indicates an error when inRate, outRate, nStep or len is less than or equal to 0.
//      ippStsBadArgErr   Indicates an error when rollf is less than or equal to 0 or is greater than 1 or if alpha is less than 1 or if window is less than 2/nStep.
//      ippStsMemAllocErr Indicates a memory allocation error.
*/

IPPAPI(IppStatus, ippsResamplePolyphaseInitAlloc_16s,(IppsResamplingPolyphase_16s** pState, Ipp32f window,
                                           int nStep, Ipp32f rollf, Ipp32f alpha,
                                           IppHintAlgorithm hint))

IPPAPI(IppStatus, ippsResamplePolyphaseInitAlloc_32f,(IppsResamplingPolyphase_32f** pState, Ipp32f window,
                                           int nStep, Ipp32f rollf, Ipp32f alpha,
                                           IppHintAlgorithm hint))

IPPAPI(IppStatus, ippsResamplePolyphaseFixedInitAlloc_16s,(IppsResamplingPolyphaseFixed_16s** pState, int inRate,
                                                int outRate, int len, Ipp32f rollf, Ipp32f alpha,
                                                IppHintAlgorithm hint))

IPPAPI(IppStatus, ippsResamplePolyphaseFixedInitAlloc_32f,(IppsResamplingPolyphaseFixed_32f** pState, int inRate,
                                                int outRate, int len, Ipp32f rollf, Ipp32f alpha,
                                                IppHintAlgorithm hint))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphase
//  Purpose:        Resample input data
//   Arguments:
//      pSpec     The pointer to the resampling state structure.
//      pSrc      The pointer to the input vector.
//      pDst      The pointer to the output vector.
//      len       The number of input vector elements to resample.
//      norm      The norming factor for output samples.
//      factor    The resampling factor.
//      pTime     The pointer to the start time of resampling (in input vector elements).
//      pOutlen   The number of calculated output vector elements
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when pSpec, pSrc, pDst, pTime or pOutlen is NULL.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0.
//      ippStsBadArgErr    Indicates an error when factor is less than or equal to.
*/

IPPAPI(IppStatus, ippsResamplePolyphase_16s,(const IppsResamplingPolyphase_16s *pState, const Ipp16s *pSrc, int len,
                                  Ipp16s *pDst, Ipp64f factor, Ipp32f norm, Ipp64f *pTime,
                                  int *pOutlen))

IPPAPI(IppStatus,  ippsResamplePolyphase_32f,(const IppsResamplingPolyphase_32f *pState, const Ipp32f *pSrc, int len,
                                  Ipp32f *pDst, Ipp64f factor, Ipp32f norm, Ipp64f *pTime,
                                  int *pOutlen))

IPPAPI(IppStatus, ippsResamplePolyphaseFixed_16s,(const IppsResamplingPolyphaseFixed_16s *pState,
                                       const Ipp16s *pSrc, int len, Ipp16s *pDst,
                                       Ipp32f norm, Ipp64f *pTime, int *pOutlen))

IPPAPI(IppStatus, ippsResamplePolyphaseFixed_32f,(const IppsResamplingPolyphaseFixed_32f *pState,
                                       const Ipp32f *pSrc, int len, Ipp32f *pDst,
                                       Ipp32f norm, Ipp64f *pTime, int *pOutlen))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseFixedGetSize
//  Purpose:        Determines the size required for the ResamplePolyphaseFixed_*
//   Arguments:
//      inRate           The input rate for resampling with fixed factor.
//      outRate         The output rate for resampling with fixed factor.
//      len              The filter length for resampling with fixed factor.
//      pSize           Required size in bytes
//      pLen            Filter len
//      pHeight         Number of filter
//      hint            Suggests using specific code. The values for the hint argument are described in "Flag and Hint Arguments"
//
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSize, pLen or pHeight are NULL.
//      ippStsSizeErr     Indicates an error when inRate, outRate or len is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsResamplePolyphaseFixedGetSize_16s,(int inRate, int outRate, int
       len, int* pSize, int* pLen, int* pHeight, IppHintAlgorithm hint))

IPPAPI(IppStatus, ippsResamplePolyphaseFixedGetSize_32f,(int inRate, int outRate, int
       len, int* pSize, int* pLen, int* pHeight, IppHintAlgorithm hint))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseFixedInit
//  Purpose:        Initializes ResamplePolyphaseFixed_* structures
//   Arguments:
//      pSpec           The pointer to the resampling state structure to be created.
//      inRate          The input rate for resampling with fixed factor.
//      outRate         The output rate for resampling with fixed factor.
//      len             The filter length for resampling with fixed factor.
//      hint            Suggests using specific code. The values for the hint argument are described in "Flag and Hint Arguments"
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSpec is NULL.
//      ippStsSizeErr     Indicates an error when inRate, outRate or len is less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsResamplePolyphaseFixedInit_16s,(IppsResamplingPolyphaseFixed_16s* pSpec,
       int inRate, int outRate, int len, IppHintAlgorithm hint))

IPPAPI(IppStatus, ippsResamplePolyphaseFixedInit_32f,(IppsResamplingPolyphaseFixed_32f* pSpec,
       int inRate, int outRate, int len, IppHintAlgorithm hint))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseSetFixedFilter
//  Purpose:        Set filter coefficient
//   Arguments:
//      pSpec           The pointer to the resampling state structure to be created.
//      pSrc            Input vector of filter coefficients [height][step]
//      step            Lenght of filter
//      height          Number of filter
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSpec or pSrc are NULL.
//      ippStsSizeErr     Indicates an error when step or height is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsResamplePolyphaseSetFixedFilter_16s,(IppsResamplingPolyphaseFixed_16s* pSpec,
       const Ipp16s* pSrc, int step, int height))

IPPAPI(IppStatus, ippsResamplePolyphaseSetFixedFilter_32f,(IppsResamplingPolyphaseFixed_32f* pSpec,
       const Ipp32f* pSrc, int step, int height))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseGetFixedFilter
//  Purpose:        Get filter coefficient
//   Arguments:
//      pSpec           The pointer to the resampling state structure to be created.
//      pDst            Input vector of filter coefficients [height][step]
//      step            Lenght of filter
//      height          Number of filter
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSpec or pSrc are NULL.
//      ippStsSizeErr     Indicates an error when step or height is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsResamplePolyphaseGetFixedFilter_16s,(IppsResamplingPolyphaseFixed_16s* pSpec,
       Ipp16s* pDst, int step, int height))


IPPAPI(IppStatus, ippsResamplePolyphaseGetFixedFilter_32f,(IppsResamplingPolyphaseFixed_32f* pSpec,
       Ipp32f* pDst, int step, int height))


/* /////////////////////////////////////////////////////////////////////////////
//                  Definitions for Audio Toolkit functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )

struct MCRAState;
typedef    struct MCRAState IppMCRAState;
struct MCRAState32f;
typedef    struct MCRAState32f IppMCRAState32f;

#endif /* _OWN_BLDPCS */

/* /////////////////////////////////////////////////////////////////////////////
//                  Definitions of Audio Toolkit functions
///////////////////////////////////////////////////////////////////////////// */

/* /////////////////////////////////////////////////////////////////////////////
// Name:            ippsFilterUpdateEMNS
// Purpose:         Calculates the Ephraim-Malah noise suppression filter coefficients
//
//                   H(k) = (0.5 * sqrt(pi * W(k) * Rp(k)) * M(W(k)*Rp(k))) / Rp(k)
//                     where,
//                         k    : frequency bin index
//                         W    : Wiener filter coefficients
//                         Rp   : posterior SNR
//                         M(T) : exp(-T/2) * [(1+T)*I0(T/2) + T*I1(T/2)]
//                   where,
//                           I0, I1 : are modified Bessel functions of order 0 and 1 respectively
//             In here, for better performance in fix-point implement, Original Ephraim-Malah
//             filter weights formula have been reformed as fellow:
//                H(k) = W(k) * M'(W(k)*Rp(k)))
//                M'(T) = 0.5 * sqrt(pi/T) * exp(-T/2) * [(1+T)*I0(T/2) + T*I1(T/2)]
//            By the new Ephraim-Malah filter weights formula, the division operation has been
//            removed.
//            M'(T) have been fix-point realized by (T is thetaQ22 in code):
//             1) Use table look-up for small value (T< 2^(-15)) to achieve high precision
//             2) Set exponential increasing band ( From 2^i to 2^(i+1) ) to keep near same
//                precision in each band. Total 24 bands used in code.
//             3) Use dynamic Q value for parameter P1 and P2 to keep high precision. P1, P2
//                and P0 are used in the formula of two-order polynomial approximations:
//                f(x) = P0 + P1 * x + P2 * x^2
//                The value of P0, P1 & P2 have been recorded in table P0_2_32SQ22, P1_2_32SQ5i
//                and P2_2_32SQi4. The Q value of P1 is (i+5), The Q value of P2 is (i-4),
//                i is the index of band (i from 0 to 23). The representation of P0 is fixed
//                at Q22 for all segments
// Arguments:
//    pSrcWienerCoefsQ31 - pointer to a real-valued vector containing the Q31 format
//                                        Wiener filter coefficients.
//    pSrcPostSNR        - pointer to a real-valued vector containing an estimate of
//                                       the a posteriori signal to noise ratio.
//    len                - number of elements contained in input and output vectors.
//    pDstFilterCoefsQ31 - pointer to a real-valued vector containing the Q31 format
//                                        filter coefficients.
//
// Returns:      ippStsNoErr      - No Error.
//               ippStsNullPtrErr - pSrcWienerCoefsQ31, pSrcPostSNRQ15 or pDstFilterCoefsQ31 is null.
//               ippStsLengthErr  - len is out of range.
//
// Notes:
*/
IPPAPI(IppStatus, ippsFilterUpdateEMNS_32s,(const Ipp32s *pSrcWienerCoefsQ31,
       const Ipp32s *pSrcPostSNRQ15, Ipp32s *pDstFilterCoefsQ31, int len))
IPPAPI(IppStatus, ippsFilterUpdateEMNS_32f,(const Ipp32f *pSrcWienerCoefs,
       const Ipp32f *pSrcPostSNR, Ipp32f *pDstFilterCoefs, int len))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsFilterUpdateWiener
//  Purpose:    Calculates Wiener filter coefficients.
//                   W(k) = 1 / (1 + 1/R(k))
//
//               with a piecewise uniform quantization table.  The table is
//               designed such that finer quantization steps are taken for
//               smaller values where the function is more sensitive and large
//               steps are taken for large values where the function is fairly
//               flat.  The table is divided into segments defined by
//
//                                         0 <= r < 2^WienerSegmentBitOffset[1]
//               2^WienerSegmentBitOffset[1] <= r < 2^WienerSegmentBitOffset[2]
//               2^WienerSegmentBitOffset[2] <= r < 2^WienerSegmentBitOffset[3]
//               2^WienerSegmentBitOffset[3] <= r
//
//               where r represents an entry of the input vector.  The number
//               of table entries in segment i of the table is
//
//                  2^(WienerSegmentBitOffset[i+1] - WienerSegmentBitOffset[i]).
//
//               Therefore, if an input pSrcPriorSNRQ15[k] falls into segment i
//               of the table then the index into the table segment is simply
//
//                  pSrcPriorSNRQ15[k] / 2^WienerSegmentBitOffset[i]
//
//               A segment offset (e.g., TABLESEG0) is provided for each segment
//               of the table.  It may be added to the above result to find the
//               offset from the beginning of the table.  Within a segment, the
//               table entries were created by uniform quantization.  Since the
//               function is flat for large values, it it represented by a
//               constant in the final segment.
// Input Arguments:  pSrcPriorSNRQ15    - pointer to the a priori SNR vector
//                                      in Q15 (x/32768) format.
//                   len - number of elements contained in input vector.
//
// Output Arguments: pDstFilterCoefsQ31 - pointer to the output vector
//                                        in Q31 format.
//
// Returns:
//                  IppStsNoErr - No Error
//                  IppStsBadArgErr - Bad Arguments
//
// Notes: none
//
*/
IPPAPI( IppStatus, ippsFilterUpdateWiener_32s,(const Ipp32s *pSrcPriorSNRQ15,
        Ipp32s *pDstFilterCoefsQ31, int len))

IPPAPI( IppStatus, ippsFilterUpdateWiener_32f,(const Ipp32f *pSrcPriorSNR,
        Ipp32f *pDstFilterCoefs, int len) )
/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsGetSizeMCRA
//  Purpose:     Returns the size of memory for noise PSD estimator
//
//  Arguments:
//    nFFTSize - number of elements contained in the input FFT.
//    pDstSize - pointer to the state structure.
//
// Returns:
//          IppStsNoErr - No Error
//          IppStsBadArgErr - Bad Arguments
//
// Notes: none
//
*/
IPPAPI( IppStatus, ippsGetSizeMCRA_32s,(int nFFTSize, int *pDstSize) )

IPPAPI( IppStatus, ippsGetSizeMCRA_32f,(int nFFTSize, int *pDstSize) )


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsInitMCRA
//  Purpose:     Initializes the noise PSD estimator
//               See page 14 of "Noise Estimation by Minima
//               Controlled Recursive Averaging for Robust Speech Enhancement"
//               by I. Cohen and B. Berdugo, IEEE Signal Proc. Letters, Vol. 9,
//               No. 1, Jan. 2002, pp. 12-15.  Since the authors only established
//               parameters for a sample rate Fs of 16000 Hz and a block update of
//               8 msec (M == 64 samples), it was necessary to derive equations
//               to support arbitrary sample rate and block update.  These
//               equations are given in the comments below.
//  Arguments:
//     nSamplesPerSec - input sample rate.
//     nFFTSize       - number of elements contained in the input FFT.
//     pDst           - pointer to the state structure.
// Returns:
//          IppStsNoErr - No Error
//          IppStsBadArgErr - Bad Arguments
//
// Notes: This function must be kept in synch with the definition of the
//        IppMCRAState.  Memory pointers are assigned according to the order
//        in the structure.
//
*/
IPPAPI( IppStatus, ippsInitMCRA_32s,(int nSamplesPerSec, int nFFTSize,
                                    IppMCRAState *pDst) )

IPPAPI( IppStatus, ippsInitMCRA_32f,(int nSamplesPerSec, int nFFTSize,
                                    IppMCRAState32f *pDst) )

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsAltInitMCRA
//  Purpose:     Initializes alternative noise PSD estimator
//
//  Arguments:
//     nSamplesPerSec - input sample rate.
//     nFFTSize       - number of elements contained in the input FFT.
//     nUpdateSamples - number of new samples per frame
//     pDst           - pointer to the state structure.
//
// Returns:
//          IppStsNoErr - No Error
//          IppStsBadArgErr - Bad Arguments
//
// Notes:  This function is a candidate to replace ippsInitMCRA_32s.  It provides
//         an added degree of flexibility so that the state can be initialized
//         properly when zero padding is used to support frame sizes that are
//         less than nFFTSize/2.
//         This function must be kept in synch with the definition of the
//         IppMCRAState.  Memory pointers are assigned according to the order
//         in the structure.
//
*/

IPPAPI( IppStatus, ippsAltInitMCRA_32s,(int nSamplesPerSec,
                                       int nFFTSize,
                                       int nUpdateSamples,
                                       IppMCRAState *pDst) )

IPPAPI( IppStatus, ippsAltInitMCRA_32f,(int nSamplesPerSec,
                                       int nFFTSize,
                                       int nUpdateSamples,
                                       IppMCRAState32f *pDst) )


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsUpdateNoisePSDMCRA
//  Purpose:     Estimates the noise power spectral density
//               using the "Minima Controlled Recursive Averaging" method.  See
//               "Noise Estimation by Minima Controlled Recursive Averaging for
//               Robust Speech Enhancement" by I. Cohen and B. Berdugo, IEEE
//               Signal Proc. Letters, Vol. 9, No. 1, Jan. 2002, pp. 12-15.  To
//               relate this source code to the paper, the following table may
//               be helpful:
//
//               Paper               Eqn  Source Code
//               =====               ===  ===========
//               |Y(k,l)|^2           4   pSrcNoisySpeech[k]
//               lambdahat_d(k,l)     4   pSrcDstNoisePSD[k] (input)
//               lambdahat_d(k,l+1)   4   pSrcDstNoisePSD[k] (output)
//               alpha_d              4   pSrcDstState->alphaDQ31
//               alphatilde_d(k,l)    4   alphaTildeDQ31
//               S(k,l-1)             7   pSrcDstState->pS[k] (input)
//               S(k,l)               7   pSrcDstState->pS[k] (output)
//               alpha_s              7   pSrcDstState->alphaSQ31
//               S_min(k,l-1)         8   pSrcDstState->pSmin[k] (input)
//               S_min(k,l)           8   pSrcDstState->pSmin[k] (output)
//               S_tmp(k,l-1)         9   pSrcDstState->pStmp[k] (input)
//               S_tmp(k,l)           9   pSrcDstState->pStmp[k] (output)
//               phatprime(k,l-1)    14   pSrcDstState->pPprimeQ31[k] (input)
//               phatprime(k,l)      14   pSrcDstState->pPprimeQ31[k] (output)
//               alpha_p             14   pSrcDstState->alphaPQ31
//
//   Arguments:
//      pSrcNoisySpeech - pointer to the magnitude squared of the FFT of the noisy speech.
//      pSrcDstState    - state structure.
//      pSrcDstNoisePSD - pointer to the input noise PSD vector.
//
//      pSrcDstState    - updated state structure.
//      pSrcDstNoisePSD - pointer to the output noise PSD vector.
//
// Returns:
//          IppStsNoErr - No Error
//          IppStsBadArgErr - Bad Arguments
//
// Notes:  For reasonable signal levels, the pSrcNoisySpeech and pSrcDstNoisePSD
//         values will need to be scaled by 2^31 during the mag-squaring
//         procedure.
//
*/
IPPAPI( IppStatus, ippsUpdateNoisePSDMCRA_32s_I, (const Ipp32s *pSrcNoisySpeech,
        IppMCRAState *pSrcDstState, Ipp32s *pSrcDstNoisePSD))

IPPAPI( IppStatus, ippsUpdateNoisePSDMCRA_32f_I, (const Ipp32f *pSrcNoisySpeech,
        IppMCRAState32f *pSrcDstState, Ipp32f *pSrcDstNoisePSD) )

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsFindPeaks
//  Purpose:     Identifies the peaks in the input vector,
//                   places a one in the output vector at the locations of the peaks
//                   and places a zero elsewhere. A peak is defined as a point pSrc[i]
//                   such that -   pSrc[i-L] < pSrc[i-L+1] <...< pSrc[i] > pSrc[i+1] > ...> pSrc[i+L]
//                   where L is the size of the search.
//                   If movingAvgSize (M) is greater than 0, the input vector is smoothed
//                   before peaks are selected -
//                      pSrc[i] = (1/(2M+1)) {pSrc[i-M] + pSrc[i-M+1] + ... + pSrc[i] + pSrc[i+1]+
//                                                   ...+ pSrc[i+M] }
//   Arguments:
//      pSrc          - pointer to the input vector
//      len           - number of elements contained in the input and output vectors
//      searchSize    - number of elements on either side to consider when peak picking
//      movingAvgSize - width of the moving average window applied before peak picking
//      pDstPeaks     - pointer to the output vector
//
// Returns:          ippStsNoErr        - No Error.
//                   ippStsBadArgErr    - Bad Arguments.
//                   ippStsSizeErr      - Error: search window greater than the internal
//                                               buffer that holds smoothed values
//
// Notes:            Search the input vector. Calculate each number of the successive ascending elements
//                   and the successive descending elements. If both the number of successive ascending
//                   elements and the number of successive descending elements are greater than searchSize,
//                   then, one peak was found.
*/
IPPAPI(IppStatus, ippsFindPeaks_32s8u,(const Ipp32s *pSrc, Ipp8u *pDstPeaks,
       int len, int searchSize, int movingAvgSize))

IPPAPI(IppStatus, ippsFindPeaks_32f8u,(const Ipp32f *pSrc, Ipp8u *pDstPeaks,
       int len, int searchSize, int movingAvgSize))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsPeriodicityLSPE
//  Purpose:      Estimates the periodicity and period of the input frame.
//                 The core algorithm used is the least-squares periodicity estimator as
//                 described in Section 4.1 of the paper:
//                   R.Tucker,"Voice activity etection using a periodicity measure",
//                   IEEE Proceedings-I Vol. 139, No. 4, August 1992
//
//                 The approach is to compute the normalized periodicity measure (R1) for
//                 all values of possible pitch periods in samples (Pmin <= P0 <= Pmax). The
//                 maximum value of R1 obtained is the estimated periodicity of the input frame
//                 and the corresponding period (P0) is the pitch period in samples of the input frame.
//
//                 The correspondence of the notation used in the paper to that used in
//                 this function is as follows:
//                      Paper   Equation   Source code
//                      -----   --------   -----------
//                      s       3, 4, 5    pSrc
//                      Pmin    2          minPeriod
//                      Pmax    2          maxPeriod
//                      P0      3, 4, 5    p
//                      I0      3, 5       i0
//                      I1      3, 4       i1
//                      R1      3          periodicityQ15
//                      K0      4, 5       n
//
//   Arguments:
//      pSrc            - pointer to the input vector containing non-negative entries
//                                     (assumed input is energy values for time-domain signal.
//      len             - number of elements contained in the input vector
//      maxPeriod       - maximum pitch period (in samples) to search
//      minPeriod       - minimum pitch period (in samples) to search
//
//      periodicityQ15  - normalized sum of the largest harmonic sampling
//      period          - period in sample that provided the maximum-energy harmonic
// Returns:          ippStsNoErr     - No Error.
//                   ippStsBadArgErr - Bad Arguments.
//
// Notes:            none
*/
IPPAPI(IppStatus, ippsPeriodicityLSPE_16s,(const Ipp16s *pSrc, int len,
       Ipp16s *periodicityQ15, int *period, int maxPeriod, int minPeriod))

IPPAPI(IppStatus, ippsPeriodicityLSPE_32f,(const Ipp32f *pSrc, int len,
       Ipp32f *periodicity, int *period, int maxPeriod, int minPeriod))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsPeriodicity
//  Purpose:       Computes the periodicity of the input vector. In typical
//                 applications, the input vector is the magnitude-squared of the discrete Fourier
//                 transform of speech.  The periodicity is defined as the periodic sampling of the
//                 input vector that preserves the most energy.
//
//                   The period is defined as P such that
//                       P = argmax_(p) sum_n[ x(b + np) ]/N
//                               where Pmin<=p<=Pmax, 0<b<p, N<=MAX_HARMONICS, 0<n<N
//                                     N is the smaller of the number of harmonics in the input vector
//                                       for a particular period (p) or MAX_HARMONICS
//
//                   Using the N,P values obtained above, the periodicity is calculated as:
//                          periodicity = sum_n[x(k+nP)] / sum_n2[x(n2)], 0<n<N, 0<n2<len
//
//
// Arguments:
//    pSrc            - pointer to the input vector containing non-negative entries
//                                     for, e.g. magnitude spectrum values
//    len             - number of elements contained in the input vector
//    maxPeriod       - maximum period to search
//    minPeriod       - minimum period of search
//
//    periodicityQ15  - normalized sum of the largest harmonic sampling
//    period          - period in sample that provided the maximum-energy harmonics
//
// Returns:          ippStsNoErr     - No Error.
//                   ippStsBadArgErr - Bad Arguments.
//
// Notes:            none
*/
IPPAPI(IppStatus, ippsPeriodicity_32s16s, (const Ipp32s *pSrc, int len,
       Ipp16s *periodicityQ15, int *period, int maxPeriod, int minPeriod))

IPPAPI(IppStatus, ippsPeriodicity_32f, (const Ipp32f *pSrc, int len,
       Ipp32f *periodicity, int *period, int maxPeriod, int minPeriod))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsNthMaxElement_*
//  Purpose:      Functions ippsNthMaxElement find N-th maximal element of
//                       the input vector pSrc.
//  Parameters:
//                pSrc       Pointer to the input vector [len].
//                len        Number of elements in the input vector pSrc.
//                N          Rank of element to find.
//                pRes       Pointer to the value of N-th maximal element.
//  Return:
//                ippStsNoErr        Indicates no error.
//                ippStsNullPtrErr   Indicates an error when pSrc or pRes is NULL.
//                ippStsSizeErr      Indicates an error when len is less than or equal to 0 or.
//                ippStsBadArgErr    Indicates an error when N is less then 0 or is greater than or equal to len.
//  Notes:
*/

IPPAPI(IppStatus, ippsNthMaxElement_32s,(const Ipp32s* pSrc, int len, int N, Ipp32s* pRes))
IPPAPI(IppStatus, ippsNthMaxElement_32f,(const Ipp32f* pSrc, int len, int N, Ipp32f* pRes))
IPPAPI(IppStatus, ippsNthMaxElement_64f,(const Ipp64f* pSrc, int len, int N, Ipp64f* pRes))





/*======== End of declaration of functions ===================================*/

#ifdef __cplusplus
}
#endif

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

#endif /* __IPPSR_H__ */
/* ////////////////////////// End of file "ippsr.h" ///////////////////////// */