/* ///////////////////////////////////////////////////////////////////////////// // // 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" ///////////////////////// */