amy/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-04 05:51:01 -05:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions
winamp/Src/external_dependencies/intel_ipp_6.1.1.035/em64t/include/ippsr.h
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

6241 lines
292 KiB
C
Raw Blame History

/* /////////////////////////////////////////////////////////////////////////////
//
// 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" ///////////////////////// */
Reference in a new issue View git blame Copy permalink