AtRiskRepos/winamp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
9171e38b2c
winamp/Src/external_dependencies/intel_ipp_6.1.1.035/ia32/include/ippsc.h

5459 lines
270 KiB
C
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
/* /////////////////////////////////////////////////////////////////////////////
//
// 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 Coding
//
*/
#if !defined( __IPPSC_H__ ) || defined( _OWN_BLDPCS )
#define __IPPSC_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 )
/* /////////////////////////////////////////////////////////////////////////////
// Speech compression bit rates structure
///////////////////////////////////////////////////////////////////////////// */
typedef enum {
IPP_SPCHBR_4750 = 0, /* 4.75 kbps GSMAMR */
IPP_SPCHBR_5150, /* 5.15 kbps GSMAMR */
IPP_SPCHBR_5300, /* 5.3 kbps G723.1 */
IPP_SPCHBR_5900, /* 5.9 kbps GSMAMR */
IPP_SPCHBR_6300, /* 6.3 kbps G723.1 */
IPP_SPCHBR_6600, /* 6.60 kbps AMRWB */
IPP_SPCHBR_6700, /* 6.7 kbps GSMAMR */
IPP_SPCHBR_7400, /* 7.4 kbps GSMAMR */
IPP_SPCHBR_7950, /* 7.95 kbps GSMAMR */
IPP_SPCHBR_8850, /* 8.85 kbps AMRWB */
IPP_SPCHBR_9600, /* 9.60 kbps G728 */
IPP_SPCHBR_10200, /* 10.2 kbps GSMAMR */
IPP_SPCHBR_12200, /* 12.2 kbps GSMAMR */
IPP_SPCHBR_12650, /* 12.65 kbps AMRWB */
IPP_SPCHBR_12800, /* 12.8 kbps G728 */
IPP_SPCHBR_14250, /* 14.25 kbps AMRWB */
IPP_SPCHBR_15850, /* 15.85 kbps AMRWB */
IPP_SPCHBR_16000, /* 16 kbps G726, G728 */
IPP_SPCHBR_18250, /* 18.25 kbps AMRWB */
IPP_SPCHBR_19850, /* 19.85 kbps AMRWB */
IPP_SPCHBR_23050, /* 23.05 kbps AMRWB */
IPP_SPCHBR_23850, /* 23.85 kbps AMRWB */
IPP_SPCHBR_24000, /* 24 kbps G726, AMRWBE */
IPP_SPCHBR_32000, /* 32 kbps G726 */
IPP_SPCHBR_40000, /* 40 kbps G726 */
IPP_SPCHBR_DTX, /* Discontinuous TX mode for various codecs*/
/* IPP_SPCHBR_6400, 6.4 kbps G729D
// IPP_SPCHBR_8000, 8.0 kbps G729
// IPP_SPCHBR_11800, 11.8 kbps G729E
// IPP_SPCHBR_13000, 13.0 kbps GSMFR
// IPP_SPCHBR_48000, 48 kbps G722
// IPP_SPCHBR_56000, 56 kbps G722
// IPP_SPCHBR_64000, 64 kbps G711, G722 */
IPP_SPCHBR_10400, /* 10.4 kbps AMRWBE */
IPP_SPCHBR_12000, /* 12.0 kbps AMRWBE */
IPP_SPCHBR_13600, /* 13.6 kbps AMRWBE */
IPP_SPCHBR_15200, /* 15.2 kbps AMRWBE, iLBC */
IPP_SPCHBR_16800, /* 16.8 kbps AMRWBE */
IPP_SPCHBR_19200, /* 19.2 kbps AMRWBE */
IPP_SPCHBR_20800, /* 20.8 kbps AMRWBE */
IPP_SPCHBR_13330 /* 13.33 kbps iLBC */
/* new bitrates to be added to the end */
} IppSpchBitRate;
typedef enum {
IPP_PCM_MULAW = 0, /* mu-Law */
IPP_PCM_ALAW, /* A-Law */
IPP_PCM_LINEAR /* uniform PCM */
} IppPCMLaw;
typedef enum {
IPP_PCM_FREQ_8000 = 8000, /* 8 kHz */
IPP_PCM_FREQ_16000 = 16000, /* 16 kHz */
IPP_PCM_FREQ_22050 = 22050, /* 22.05 kHz */
IPP_PCM_FREQ_32000 = 32000, /* 32 kHz */
IPP_PCM_FREQ_11025 = 11025
} IppPCMFrequency;
typedef enum {
ippsNrNone,
ippsNrLow,
ippsNrMedium,
ippsNrNormal,
ippsNrHigh,
ippsNrAuto
} IppsNRLevel;
typedef enum {
ippsNrNoUpdate=-1,
ippsNrUpdate,
ippsNrUpdateAll
} IppsNrMode;
typedef enum {
ippsNrSmoothDynamic=-1,
ippsNrSmoothStatic,
ippsNrSmoothOff
} IppsNrSmoothMode;
typedef enum {
IPP_G722_VOICED,
IPP_G722_UNVOICED,
IPP_G722_TRANSIENT,
IPP_G722_WEAKLY_VOICED,
IPP_G722_VUV_TRANSITION
} IppG722SBClass;
typedef struct {
Ipp16s pPrevSignalSublevel[9]; /* signal sublevel vector */
Ipp16s pPrevSignalLevel[9]; /* previous signal level vector */
Ipp16s pPrevAverageLevel[9]; /* average signal level */
Ipp16s pBkgNoiseEstimate[9]; /* background noise estimate vector */
Ipp16s pFifthFltState[6]; /* 5th order filters history */
Ipp16s pThirdFltState[5]; /* 3rd order filters history */
Ipp16s burstCount; /* burst counter */
Ipp16s hangCount; /* hangover counter */
Ipp16s statCount; /* stationarity counter */
Ipp16s vadReg; /* intermediate vad decision */
Ipp16s complexHigh; /* high for complex signal decision */
Ipp16s complexLow; /* low for ccomplex signal decision */
Ipp16s complexHangTimer; /* complex hangover timer */
Ipp16s complexHangCount; /* complex hangover counter */
Ipp16s complexWarning; /* complex_warining flag */
Ipp16s corrHp; /* High-pass filtered signal correlation */
Ipp16s pitchFlag; /* pitch flag by pitch detection */
} IppGSMAMRVad1State;
typedef struct {
Ipp32s pEngyEstimate[16]; /* channel energy estimate vector of */
/* current half-frame */
Ipp32s pNoiseEstimate[16]; /* channel noise estimate vector of */
/* current half-frame */
Ipp16s pLongTermEngyDb[16]; /* channel long-term log energy vector */
/* of current half-frame */
Ipp16s preEmphasisFactor; /* pre-emphasize factor */
Ipp16s updateCount; /* update counter */
Ipp16s lastUpdateCount; /* last update counter */
Ipp16s hysterCount; /* hyster counter */
Ipp16s prevNormShift; /* previous normalize shift bits */
Ipp16s shiftState; /* previous half-frame shift state */
Ipp16s forcedUpdateFlag; /* forced update flag */
Ipp16s ltpSnr; /* long-term peak SNR */
Ipp16s variabFactor; /* background noise variability factor */
Ipp16s negSnrBias; /* negative SNR sensitivity Bias */
Ipp16s burstCount; /* burst counter */
Ipp16s hangOverCount; /* hangover counter */
Ipp32s frameCount; /* frame counter */
} IppGSMAMRVad2State;
typedef struct Ipp32s_EC_Sfs_Def {
Ipp32s val;
Ipp32s sf;
} Ipp32s_EC_Sfs;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Functions declarations
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippscGetLibVersion
// Purpose: getting of the library version
// Returns: the structure of information about version
// of ippSC library
// Parameters:
//
// Notes: not necessary to release the returned structure
*/
IPPAPI( const IppLibraryVersion*, ippscGetLibVersion, (void) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilterSize
// Purpose: Knowing of G729 high pass preprocessing filter size demand
// Parameters:
// pSize Pointer to the output value of the memory size needed for filtering
// Returns:
// ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsHighPassFilterSize_G729, (int *pSize) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilterInit
// Purpose: Initialization of the memory allocated for preprocessing filter
// Parameters:
// pMem pointer to the memory supplied for filtering
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI( IppStatus, ippsHighPassFilterInit_G729, (const Ipp16s *pCoeff, char* pMem) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilter
// Purpose: G729 input signal preprocessing, consists of two functions applied:
// - scaling ( divide by a factor 2)
// - high-pass filtering
// Parameters:
// pSrcDst pointer to the vector for inplace operation
// pMem pointer to the memory supplied for filtering
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsHighPassFilter_G729_16s_ISfs, (Ipp16s* pSrcDst, int len, int scaleFactor,
char* pMem) )
IPPAPI( IppStatus, ippsHighPassFilter_G723_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int* pMem) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMul
// Purpose: multiply operations upon every element of
// the source vectors.
// rounding to nearest:
// const1 = 1<<(scaleFactor-1)
// (a*b+const1)>>scaleFactor;
// Parameters:
// pSrc pointer to the input vector
// pSrc1 pointer to the first source vector
// pSrc2 pointer to the second source vector
// pDst pointer to the output vector
// pSrcDst pointer to the source/destination vector
// len length of the vectors
// scaleFactor scale factor value
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsMul_NR_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len, int scaleFactor) )
IPPAPI( IppStatus, ippsMul_NR_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst,
int len, int scaleFactor) )
IPPAPI( IppStatus, ippsMulC_NR_16s_ISfs, (Ipp16s val, Ipp16s* pSrcDst, int len, int scaleFactor) )
IPPAPI( IppStatus, ippsMulC_NR_16s_Sfs, ( const Ipp16s* pSrc, Ipp16s val, Ipp16s* pDst,
int len, int scaleFactor) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMulPowerC
// Purpose: power weighting of every element of the source vectors
// dst[i] = pow(val, i)*src[i] ; i=0..len-1
// with rounding to nearest:
// const1 = 1<<(scaleFactor-1)
// (a*b+const1)>>scaleFactor;
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// scaleFactor scale factor value
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsMulPowerC_NR_16s_Sfs, (const Ipp16s* pSrc, Ipp16s val, Ipp16s* pDst,
int len, int scaleFactor) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsInvSqrt
// Purpose: Inverted square root with normalization
// Parameters:
// pSrcDst pointer to the input/output vector
// len length of the input vector
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsInvSqrt_32s_I, (Ipp32s *pSrcDst, int len ) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAutoScale
// Purpose: Autoscaling: Find and normalize (shift left) the absolute
// maximal element and then do the same shift for all other elements
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// pSrcDst pointer to the input/output vector
// len length of the input vector
// pScale pointer to the output scaling factor
// (number of bit the output vector has been shifted left)
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsAutoScale_16s, (const Ipp16s *pSrc, Ipp16s *pDst, int Len , int *pScale) )
IPPAPI( IppStatus, ippsAutoScale_16s_I, ( Ipp16s *pSrcDst, int Len , int *pScale) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAutoCorrLagMax
// Purpose: Find the maximum of the correlation for the given lag range
// r[lag]=SUM(n=0,...,len-1) src[n]*src[n-lag] - backward
// r[lag]=SUM(n=0,...,len-1) src[n]*src[n+lag] - forward
// within the range [lowerLag,upperLag] of the lags.
// Parameters:
// pSrc pointer to the input vector
// len length of the input vector
// lowerLag lower input lag value
// upperLag upper input lag value
// pMax pointer to the output maximum of the correlation
// maxLag pointer to the output lag value that hold maximum
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsAutoCorrLagMax_Fwd_16s, (const Ipp16s *pSrc, int len, int lowerLag,
int upperLag, Ipp32s *pMax, int *maxLag ) )
IPPAPI( IppStatus, ippsAutoCorrLagMax_Inv_16s, (const Ipp16s *pSrc, int len, int lowerLag,
int upperLag, Ipp32s *pMax, int *maxLag ) )
IPPAPI( IppStatus, ippsAutoCorrLagMax_32f,(const Ipp32f *pSrc, int len, int lowerLag,
int upperLag, Ipp32f *pMax, int *maxLag ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAutoCorr_NormE
// Purpose: Compute autocorrelation using formula:
// r[n]=SUM(i=0,...,len-n-1) src[i]*src[i+n], n=0,...,lenDst-1
// Norm in function name means multiplication of result by normalzation factor
// of corr[0].
// Parameters:
// pSrc pointer to the input vector
// len length of the input vector
// step
// pDst pointer to the output autocorrelation vector
// lenDst length of the output vector
// Returns: ippStsNoErr, if no errors
// ippStsOverflow, if at least one result really was saturated
*/
IPPAPI( IppStatus, ippsAutoCorr_16s32s,
(const Ipp16s *pSrc, int srcLen, Ipp32s *pDst, int dstLen ))
IPPAPI( IppStatus, ippsAutoCorr_NormE_16s32s, (const Ipp16s *pSrc, int len, Ipp32s *pDst,
int lenDst, int *pNorm) )
IPPAPI( IppStatus, ippsAutoCorr_NormE_NR_16s, (const Ipp16s *pSrc, int len, Ipp16s *pDst,
int lenDst, int *pNorm) )
IPPAPI( IppStatus, ippsAutoCorr_NormE_G723_16s, (const Ipp16s *pSrc, Ipp16s *pDst, int *pNorm) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsToeplizMatrix
// Purpose: Compute of the autocorrelation matrix for the impulse response
// Parameters:
// pSrc pointer to the input vector (Impulse response)
// pDst pointer to the output autocorrelation matrix
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsToeplizMatrix_G729_16s32s,(const Ipp16s *pSrcImpulseResponse, Ipp32s *pDstMatrix))
IPPAPI( IppStatus, ippsToeplizMatrix_G729_16s, (const Ipp16s *pSrcImpulseResponse, Ipp16s *pDstMatrix))
IPPAPI( IppStatus, ippsToeplizMatrix_G723_16s32s,(const Ipp16s *pSrcImpulseResponse, Ipp32s *pDstMatrix))
IPPAPI( IppStatus, ippsToeplizMatrix_G723_16s, (const Ipp16s *pSrcImpulseResponse, Ipp16s *pDstMatrix))
IPPAPI( IppStatus, ippsToeplizMatrix_G729_32f, (const Ipp32f *pSrcImpulseResponse, Ipp32f *pDstMatrix))
IPPAPI( IppStatus, ippsToeplizMatrix_G729D_32f, (const Ipp32f *pSrcImpulseResponse, Ipp32f *pDstMatrix))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCrossCorr
// Purpose: Compute crosscorrelation of two vectors using formula:
// r[k]=SUM(i=k,...,len) src2[i]*src1[j-i] k=0,...,lenDst-1
// result is scaled so that the crosscorrelation maximum is int 13 bit
// Parameters:
// pSrc1 pointer to the input vector
// pSrc2 pointer to the input vector
// len length of the correlation
// pDst pointer to the output crosscorrelation vector
// lenDst length of the output vector
// scaleFactor Scale factor of the destination vector.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsCrossCorr_NormM_16s, (const Ipp16s *pSrc1, const Ipp16s *pSrc2, int len,
Ipp16s *pDst) )
IPPAPI( IppStatus, ippsCrossCorr_16s32s_Sfs, (const Ipp16s *pSrc1, const Ipp16s *pSrc2, int len,
Ipp32s *pDst, int scaleFactor) )
IPPAPI(IppStatus, ippsCrossCorr_NR_16s, ( const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len,
Ipp16s* pDst, int lenDst))
IPPAPI ( IppStatus, ippsCrossCorr_NR_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp16s* pDst, int lenDst, int scaleFactor))
IPPAPI ( IppStatus, ippsCrossCorr_NR_16s32s, (const Ipp16s *pSrc1, const Ipp16s *pSrc2, Ipp32s len, Ipp32s *pDst, Ipp32s lenDst))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCrossCorrLagMax
// Purpose: Find the maximum of the cross-correlation for the given lag range [0,lag]
// r[lag]=SUM(n=0,...,len-1) src1[n]*src2[n+lag]
// within the range [lowerLag,upperLag] of the lags.
// Parameters:
// pSrc pointer to the input vector
// len length of the input vector
// lag max lag value
// pMax pointer to the output maximum of the correlation
// pMaxLag pointer to the output lag value that hold maximum
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsCrossCorrLagMax_16s, (const Ipp16s *pSrc1, const Ipp16s *pSrc2, int len,
int lag, Ipp32s *pMax, int *pMaxLag))
IPPAPI(IppStatus, ippsCrossCorrLagMax_32f64f,(const Ipp32f *pSrc1, const Ipp32f *pSrc2, int len,
int lag, Ipp64f *pMax, int *pMaxLag ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsOpenLoopPitchSearch
// Purpose: Find the best codebook delay by open-loop pitch analysis
// r[lag]=SUM(n=0,...,L_FRAME-1) src[n]*src[n-lag]
// within the range [lowerLag,upperLag] of the lags.
// Parameters:
// pSrc pointer to the input vector of range [pSrc-upperLag,pSrc+L_FRAME-1]
// bestLag pointer to the output best open-loop pitch lag
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsOpenLoopPitchSearch_G729_16s, (const Ipp16s *pSrc, Ipp16s* bestLag) )
IPPAPI( IppStatus, ippsOpenLoopPitchSearch_G729A_16s,(const Ipp16s *pSrc, Ipp16s* bestLag) )
IPPAPI( IppStatus, ippsOpenLoopPitchSearch_G729A_32f,(const Ipp32f *pSrc, Ipp32s* bestLag))
IPPAPI( IppStatus, ippsOpenLoopPitchSearch_G723_16s, (const Ipp16s *pSrc, Ipp16s* bestLag ) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDotProd
// Purpose: Compute dot product of two input signals using formula:
// energy=SUM(n=0,...,len-1) src1[n]*src2[n]
// AutoScale function interchange downscaling by 1 of input vectors until
// no overflow occured, returns total number of shifts right.
// Parameters:
// pSrc1 pointer to the first input vector
// pSrc2 pointer to the second input vector
// len length of each input vectors
// pDp pointer to the output result value
// pSfs pointer to the output total number of shifts right done to avoid overflow
// Returns: ippStsNoErr, if no errors
// ippStsOverflow, if at least one result really was saturated
*/
IPPAPI( IppStatus, ippsDotProd_G729A_16s32s,
(const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32s* pDp) )
IPPAPI( IppStatus, ippsDotProd_G729A_32f,
(const Ipp32f* pSrc1, const Ipp32f* pSrc2, int len, Ipp32f* pDp) )
IPPAPI( IppStatus, ippsDotProdAutoScale_16s32s_Sfs,
(const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32s* pDp, int *pSfs) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLagWindow
// Purpose: A 60 Hz bandwidth expansion is applied to input auto-correlation
// r[0]=1.0001*r[0];
// r[k]=wlag[k]*r[k];
// 60 Hz bandwidth expansion coefficients
// w_lag(k)=exp[-1/2*(2*pi*f0*k/fs)^2]
// where : f0 = 60 Hz
// fs = 8000 Hz
// Parameters:
// pSrcDst pointer to the autocorrelation vector
// len length of the autocorrelation vector
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsLagWindow_G729_32s_I, (Ipp32s *pSrcDst, int len) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSPToLSF
// pLSF[i] = arccos(pLSP[i]); i=0,...,10
// pLSP pointer to the LSP input vector of values 15 bit scaled in range [-1:1]
// pLSF pointer to the LSF output vector
// ippsLSPToLSF_G729_16s: 13 bit scaled in range [0:pi]
// ippsLSPToLSF_Norm_G729_16s: 15 bit scaled in range [0:0.5]
// Parameters:
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsLSPToLSF_G729_16s, (const Ipp16s *pLSP, Ipp16s *pLSF) )
IPPAPI( IppStatus, ippsLSPToLSF_Norm_G729_16s, (const Ipp16s *pLSP, Ipp16s *pLSF) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSFQuant
// Purpose: Quantize of LSPs
// Parameters:
// pLSF pointer to the input vector of LSF representation of LSP
// pQuantLSFTable pointer to the table of the previously quantized LSFs
// prevLSF pointer to the input vector of previously quantized LSFs
// pQuantLSF pointer to the output vector of quantized LSF
// quantIndex pointer to the output combined codebook indices
// G729 - MA,L0,L1,L2
// Returns: ippStsNoErr, if no errors
// ippStsLSFHigh, ippStsLSFLow or ippStsLSFLowAndHigh warnings
*/
IPPAPI( IppStatus, ippsLSFQuant_G729_16s, (const Ipp16s *pLSF, Ipp16s *pQuantLSFTable,
Ipp16s *pQuantLSF, Ipp16s *quantIndex) )
IPPAPI( IppStatus, ippsLSFQuant_G729B_16s, (const Ipp16s *pLSF, Ipp16s *pQuantLSFTable,
Ipp16s *pQuantLSF, Ipp16s *quantIndex) )
IPPAPI ( IppStatus, ippsLSFQuant_G729B_32f,(const Ipp32f *pLSF, Ipp32f *pQuantLSFTable,
Ipp32f *pQuantLSF, int *quantIndex) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSFDecode
// Purpose: Construct LSFs by codebook indices
// Parameters:
// quantIndex pointer to the input vector of codebook indices ( L0,L1,L2 )
// pQuantLSFTable pointer to the table of previously quantized LSFs
// pPrevLSF pointer to the input vector of the previously quantized LSFs
// pLSF pointer to the constructed LSF output vector
// Returns: ippStsNoErr, if no errors
// ippStsLSFHigh, ippStsLSFLow or ippStsLSFLowAndHigh warnings
*/
IPPAPI( IppStatus, ippsLSFDecode_G729_16s, (const Ipp16s *quantIndex, Ipp16s *pQuantLSPTable,
Ipp16s *pQuantLSF) )
IPPAPI (IppStatus, ippsLSFDecode_G729_32f, (const int *quantIndex, Ipp32f *pQuantLSFTable,
Ipp32f *pQuantLSF) )
IPPAPI( IppStatus, ippsLSFDecodeErased_G729_16s, (Ipp16s maIndex, Ipp16s *pQuantLSFTable,
const Ipp16s *pLSF) )
IPPAPI ( IppStatus,ippsLSFDecodeErased_G729_32f, (int maIndex, Ipp32f *pQuantLSFTable,
const Ipp32f *pSrcPrevLSF))
IPPAPI( IppStatus, ippsLSFDecode_G729B_16s, (const Ipp16s *quantIndex, Ipp16s *pQuantLSFTable,
Ipp16s *pLSF) )
IPPAPI ( IppStatus, ippsLSFDecode_G729B_32f,(const int *quantIndex, Ipp32f *pQuantLSFTable, Ipp32f *pDstQLsp ))
IPPAPI( IppStatus, ippsLSFDecode_G723_16s, ( const Ipp16s *quantIndex, const Ipp16s *pPrevLSF,
int erase, Ipp16s *pLSF ) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSFToLSP
// Purpose: LSF interpolation and conversion to LPC
// Parameters:
// pLSF pointer to the LSF input vector
// pLPC pointer to the LPC output vector of values in range [-1,1] 15 bit scaled
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI( IppStatus, ippsLSFToLSP_G729_16s, (const Ipp16s *pLSF, Ipp16s *pLSP) )
IPPAPI( IppStatus, ippsLSFToLSP_GSMAMR_16s, (const Ipp16s *pLSF, Ipp16s *pLSP) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsInterpolation
// Purpose: interpolation of two vector
// ippsInterpolation_G729_16s: dst = ((src1+sign(src1) )>>1+((src2+sign(src2) )>>1
// ippsInterpolationC_G729_16s_Sfs: dst = (val1*src1+val2*src2)>>scaleFactor
// ippsInterpolation_GSMAMR_16s: dst = (src1>>2)+(src2-(src2>>2))
// Parameters:
// pSrc1 pointer to the input vector1
// pSrc2 pointer to the input vector2
// pDst pointer to the interpolated output vector
// val1 interp. coeff. of first vector
// val2 interp. coeff. of second vector
// scaleFactor scaling factor to apply to the result
// len length of the vectors
/ Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsInterpolate_G729_16s, (const Ipp16s *pSrc1, const Ipp16s *pSrc2,
Ipp16s *pDst, int len) )
IPPAPI( IppStatus, ippsInterpolateC_G729_16s_Sfs, (const Ipp16s *pSrc1, Ipp16s val1,
const Ipp16s *pSrc2, Ipp16s val2, Ipp16s *pDst, int len, int scaleFactor) )
IPPAPI( IppStatus, ippsInterpolateC_NR_G729_16s_Sfs, (const Ipp16s *pSrc1, Ipp16s val1,
const Ipp16s *pSrc2, Ipp16s val2, Ipp16s *pDst, int len, int scaleFactor) )
IPPAPI( IppStatus, ippsInterpolateC_G729_32f,(const Ipp32f *pSrc1, Ipp32f val1,
const Ipp32f *pSrc2, Ipp32f val2, Ipp32f *pDst, int len))
IPPAPI ( IppStatus, ippsInterpolate_GSMAMR_16s,
(const Ipp16s *pSrc1, const Ipp16s *pSrc2, Ipp16s *pDst, int len))
/* ////////////////////////////////////////////////////////////////////////////////////////
// Name: ippsLSPToLPC
// Purpose: LSP conversion to LPC
// Parameters:
// pLSP pointer to the LSP input vector
// pLPC pointer to the LPC output vector of values in range [-1,1] 15 bit scaled
// pLSFLPC pointer to the input LSF/output LPC vector
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI( IppStatus, ippsLSPToLPC_G729_16s, (const Ipp16s *pSrcLSP, Ipp16s *pDstLPC) )
IPPAPI( IppStatus, ippsLSPToLPC_G729_32f, (const Ipp32f *pSrcLSP, Ipp32f *pDstLPC) )
/* ///////////////////////////////////////////////////////////////////////////////////////
// Name: ippsResidualFilter
// Purpose: Compute the LPC residual by filtering the input speech through A(z)
// Parameters:
// pSrc pointer to the input vector[-order,..,-1,0,...,,len-1]
// pSrcLPC pointer to the input LPC
// pDst pointer to the output vector of length[len]
// order LPC filer order
// len length of output vector
// With default order=10, len=40 for ippsResidualFilter_G729_16s
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI( IppStatus, ippsResidualFilter_G729_16s, ( const Ipp16s * pSrc, const Ipp16s * pSrcLPC,
Ipp16s * pDst) )
IPPAPI( IppStatus, ippsResidualFilter_G729E_16s,(
const Ipp16s *pSrcLPC, Ipp16s order, const Ipp16s *pSrc, Ipp16s *pDst, int len))
/* ///////////////////////////////////////////////////////////////////////////////////////
// Name: ippsSynthesisFilter
// Purpose: Compute the speech signal by synthesis filtering of the input speech through
// 1/A(z)
// Parameters:
// pSrc,pSrcSignal pointer to the input vector[len]
// pLPC pointer to the input LPC[0,..,10]
// pSrcLpc pointer to the input LPC[0,..,order]
// pSrcDst pointer to the history input/filtered output
// pDst,pSrcDstSignal pointer to the filtered output vector[len]
// pMem Pointer to the memory[-10,...,-1] supplied for filtering
// pSrcDstSynFltMemory Pointer to the memory[-order,..,-1] supplied for filtering
// Returns: ippStsNoErr, if no errors
// ippStsOverflow, if at least one result really was saturated
*/
IPPAPI( IppStatus, ippsSynthesisFilter_NR_16s_Sfs, (const Ipp16s * pLPC, const Ipp16s * pSrc,
Ipp16s * pDst, int len, int scaleFactor, const Ipp16s *pMem) )
IPPAPI( IppStatus, ippsSynthesisFilterLow_NR_16s_ISfs, (const Ipp16s * pLPC, Ipp16s * pSrcDst,
int len, int scaleFactor, const Ipp16s *pMem) )
IPPAPI( IppStatus, ippsSynthesisFilter_NR_16s_ISfs, (const Ipp16s * pLPC, Ipp16s * pSrcDst,
int len, int scaleFactor, const Ipp16s *pMem) )
IPP_DEPRECATED("use ippsSynthesisFilter_NR_16s_Sfs function instead of this one")\
IPPAPI( IppStatus, ippsSynthesisFilter_G729_16s,
(const Ipp16s * pSrcResidual, const Ipp16s * pSrcLPC, Ipp16s * pSrcDstSpch))
IPPAPI(IppStatus, ippsSynthesisFilterZeroStateResponse_NR_16s,
(const Ipp16s * pSrcLPC, Ipp16s * pDstImp, int len, int scaleFactor))
IPPAPI( IppStatus, ippsSynthesisFilter_G729E_16s,(
const Ipp16s *pSrcLpc, Ipp16s order, const Ipp16s *pSrcSignal,
Ipp16s *pDstFltSignal, int len, Ipp16s *pSrcDstSynFltMemory))
IPPAPI( IppStatus, ippsSynthesisFilter_G729_32f,(
const Ipp32f *pSrcLpc, Ipp32s order, const Ipp32f *pSrcSignal,
Ipp32f *pDstFltSignal, int len, Ipp32f *pSrcDstSynFltMemory))
IPPAPI( IppStatus, ippsSynthesisFilter_G729E_16s_I,(
const Ipp16s *pSrcLpc, Ipp16s order, Ipp16s *pSrcDstSignal,
int len, Ipp16s *pSrcDstSynFltMemory))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvPartial
// Purpose: Linear Convolution of 1D signals
// dst[n] = sum(i=[0,n])(src1[i]*src2[n-i]), n=[0,len-1]
// computation is the same as for
// ippsConv_16s32s(pSrc1,len,pSrc2,len,pDst)
// but only len results are computed and written to destination vector.
// dst[n] = sum(i=[0,n])(src1[i]*src2[n-i]), n=[0,len-1]
// NR: rounding to nearest:
// const1 = 1<<(scaleFactor-1)
// (a*b+const1)>>scaleFactor;
// Parameters:
// pSrc1 pointer to the first source vector
// pSrc2 pointer to the second source vector
// pDst pointer to the destination vector
// len length of the destination vector
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsConvPartial_NR_Low_16s,(const Ipp16s *pSrc1,
const Ipp16s *pSrc2, Ipp16s *pDst, int len))
IPPAPI(IppStatus, ippsConvPartial_NR_16s,
(const Ipp16s *pSrc1,const Ipp16s *pSrc2, Ipp16s *pDst, int len))
IPPAPI(IppStatus, ippsConvPartial_16s_Sfs,
( const Ipp16s* pSrc1, const Ipp16s* pSrc2, Ipp16s* pDst, int len, int scaleFactor) )
IPPAPI(IppStatus, ippsConvPartial_16s32s,
( const Ipp16s* pSrc1, const Ipp16s* pSrc2, Ipp32s* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecodeAdaptiveVector
// Purpose: Compute adaptive-codebook vector by interpolatindg the past excitation signal
// at the given integer delay and fraction
// Parameters:
// pSrcDstPrevExcitation pointer to the source/destination past excitation signal
// pDstAdptVector pointer to the destination adaptive-codebook vector
// pSrcDelay pointer to fractional pitch delay:
// pSrcDelay[0] - pitch delay
// pSrcDelay[1] - pitch fraction
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsDecodeAdaptiveVector_G729_16s_I,(const Ipp16s * pSrcDelay,
Ipp16s * pSrcDstPrevExcitation))
IPPAPI( IppStatus, ippsDecodeAdaptiveVector_G729_32f_I,(const Ipp32s * pSrcDelay,
Ipp32f * pSrcDstPrevExcitation))
IPPAPI( IppStatus, ippsDecodeAdaptiveVector_G729_16s,(const Ipp16s * pSrcDelay,
Ipp16s * pSrcDstPrevExcitation, Ipp16s * pDstAdptVector))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookContribution
// Purpose: Update target vector for codebook search
// by subtracting the adaptive codebook contribition:
// pDstFltAdptVector[i] = pSrcAdptTarget[i]-gain*pDstFltAdptVector[i];
// G.729 3.8.1
// Parameters:
// gain adaptive codebook gain
// pFltAdptVector pointer to the filtered adaptive codebook vector y(n)
// pSrcAdptTarget pointer to the target signal
// pDstAdptTarget pointer to the output target signal
(updated by subtracting the adaptive codebook contribition)
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus,ippsAdaptiveCodebookContribution_G729_16s, (Ipp16s gain,
const Ipp16s *pFltAdptVector, const Ipp16s *pSrcAdptTarget, Ipp16s* pDstAdptTarget))
IPPAPI(IppStatus, ippsAdaptiveCodebookContribution_G729_32f,(Ipp32f gain,
const Ipp32f *pFltAdptVector, const Ipp32f *pSrcAdptTarget, Ipp32f* pDstAdptTarget))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFixedCodebookSearch
// Purpose: Search in fixed codebook for four non zero pulses, which minimize MSE
// between the weighted input speech and weighted teconstructed speech.
// The target signal used in the close-loop pitch search is updated by
// substracting of adaptive-codebook contribution by formulae:
// x[n] = x[n] - g*y[n], n=0,...,39
// where: g - adaptive-codebook gain
// y - filtered adaptive-codebook vector
// x - weighted input
// Parameters:
// pSrcFixedCorr pointer to the correlation vector of the impulse response and target
// pSrcDstMatrix pointer to the correlation matrix of impulse response.
// pDstFixedVector pointer to the output selected acodeword
// pSearchTimes pointer to the input/output extra searching time
// pDstFixedIndex pointer to the output codeword index
// pSrc1 pointer to the correlation vector of the impulse response and target
// pSrcDst pointer to the correlation matrix of impulse response.
// pSrc2 Impulse response
// pDst1 pointer to the output selected acodeword
// pDst2 pointer to the output filteredcodeword
// pSign pointer to the output sign of 4 pulses selected
// subFrame input sub frame number (0,1)
// extraTime pointer to the input/output extra searching time
// pDstFixedIndex pointer to the output codeword index
// valLpMode Backward / Forward LP mode indication
// len length of the destination vectors
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsFixedCodebookSearch_G729_32s16s, (const Ipp16s *pSrcFixedCorr,
Ipp32s *pSrcDstMatrix, Ipp16s *pDstFixedVector,
Ipp16s *pDstFixedIndex, Ipp16s *pSearchTimes, Ipp16s subFrame))
IPPAPI(IppStatus, ippsFixedCodebookSearch_G729_16s, (const Ipp16s *pSrcFixedCorr,
Ipp16s *pSrcDstMatrix, Ipp16s *pDstFixedVector,
Ipp16s *pDstFixedIndex, Ipp16s *pSearchTimes, Ipp16s subFrame))
IPPAPI(IppStatus,ippsFixedCodebookSearch_G729A_32s16s,(const Ipp16s *pSrcFixedCorr,
Ipp32s *pSrcDstMatrix, Ipp16s *pDstFixedVector, Ipp16s *pDstFixedIndex))
IPPAPI(IppStatus,ippsFixedCodebookSearch_G729A_16s,(const Ipp16s *pSrcFixedCorr,
Ipp16s *pSrcDstMatrix, Ipp16s *pDstFixedVector, Ipp16s *pDstFixedIndex))
IPPAPI(IppStatus, ippsFixedCodebookSearch_G729E_16s,(
Ipp16s valLpMode, const Ipp16s* pSrcFixedTarget, const Ipp16s* pSrcLtpResidual,
const Ipp16s* pSrcImpulseResponse, Ipp16s* pDstFixedVector, Ipp16s* pDstFltFixedVector,
Ipp16s* pDstFixedIndex))
IPPAPI(IppStatus, ippsFixedCodebookSearch_G729D_16s,(const Ipp16s *pSrcFixedCorr,
const Ipp16s *pSrcImpulseResponse, Ipp16s *pDstFixedVector, Ipp16s *pDstFltFixedVector,
Ipp16s *pDstSign, Ipp16s *pDstFixedIndex))
IPPAPI(IppStatus, ippsFixedCodebookSearch_G729_32f,(const Ipp32f *pSrcFixedCorr,
Ipp32f *pSrcDstMatrix, Ipp32f *pDstFixedVector, Ipp32s *pDstFixedIndex,
Ipp32s *pSearchTimes, Ipp32s subFrame))
IPPAPI(IppStatus,ippsFixedCodebookSearch_G729A_32f,(const Ipp32f *pSrcFixedCorr,
Ipp32f *pSrcDstMatrix, Ipp32f *pDstFixedVector, Ipp32s *pDstFixedIndex))
IPPAPI(IppStatus,ippsFixedCodebookSearch_G729D_32f,(Ipp32f *pSrcDstFixedCorr,
Ipp32f *pSrcDstMatrix, const Ipp32f *pSrcImpulseResponse,
Ipp32f *pDstFixedVector, Ipp32f *pDstFltFixedVector, Ipp32s *pDstFixedIndex))
IPPAPI(IppStatus,ippsFixedCodebookSearch_G729E_32f, (int mode,
Ipp32f *pSrcDstFixedCorr, const Ipp32f *pSrcLtpResidual,
const Ipp32f *pSrcImpulseResponse, Ipp32f *pDstFixedVector,
Ipp32f *pDstFltFixedVector, Ipp32s *pDstFixedIndex))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHarmonicFilter
// Purpose: Enchance harmonic component of signal by formulae:
// y[n] = x[n] + val * x[n-T] - harmonic nose shaping: 1+val*z^(-T)
// y[n] = y[n] + val * y[n-T] - adaptive pre-filter: 1/(1-val*z^(-T) )
// Parameters:
// val the input factor of filter
// T the value of delay
// pSrc pointer to the input vector
// pDst pointer to the output vector
// pSrcDst pointer to the input/output vector
// len number of output results needed.
// pSrc[-T,1] or pSrcDst[-T,-1] shell be done
// pDst[0,len-1] or pSrcDst[0,len-1] will be computed.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsHarmonicFilter_16s_I,(Ipp16s val, int T, Ipp16s *pSrcDst, int len) )
IPPAPI( IppStatus, ippsHarmonicFilter_32f_I,(Ipp32f val, int T, Ipp32f *pSrcDst, int len) )
IPPAPI( IppStatus, ippsHarmonicFilter_NR_16s, (Ipp16s val, int T, const Ipp16s *pSrc,
Ipp16s *pDst, int len) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainQuant
// Purpose: Quantization of the adaptive codebook gains
// Parameters:
// pSrcAdptTarget pointer to the input target vector x(n).
// pSrcFltAdptVector pointer to the input filtered adaptive codebook vector y(n)
// pSrcFixedVector pointer to the input pre-filtered codebook contribition c(n)
// pSrcFltFixedVector pointer to the input filtered codebook vector z(n)
// pSrcDstEnergyErr pointer to the input/output energy error vector
// for 4 previous subframes
// pDstQGain pointer to the output gains:
// gain pitch = pDstQGainIndex[0]
// gain code = pDstQGainIndex[1]
// pDstQGainIndex pointer to the output codebook indexes found
// tameProcess 1 - taming is needed
//
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsGainQuant_G729_16s, (
const Ipp16s *pSrcAdptTarget, const Ipp16s *pSrcFltAdptVector,
const Ipp16s * pSrcFixedVector, const Ipp16s *pSrcFltFixedVector,
Ipp16s *pSrcDstEnergyErr, Ipp16s *pDstQGain, Ipp16s *pDstQGainIndex, Ipp16s tameProcess))
IPPAPI(IppStatus, ippsGainQuant_G729D_16s, (
const Ipp16s *pSrcAdptTarget, const Ipp16s *pSrcFltAdptVector,
const Ipp16s *pSrcFixedVector, const Ipp16s *pSrcFltFixedVector,
Ipp16s *pSrcDstEnergyErr, Ipp16s *pDstQGain, Ipp16s *pDstQGainIndex, Ipp16s tameProcess))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainCodebookSearch_G729
// Purpose: Searching procedure used in adaptive codebook gains quantization
// gain pitch = gcdbk1[pDstIdxs[0]][0] + gcdbk2[pDstIdxs[1]][0]
// gain code = gcdbk1[pDstIdxs[0]][1] + gcdbk2[pDstIdxs[1]][1]
// where gcdbk1 = gbk1_6k, gcdbk2 = gbk1_6k for D mode
// gcdbk1 = gbk1, gcdbk2 = gbk1 for other then D modes
// Parameters:
// pSrcCorr Pointer to the correlations :
// pSrcCorr[0] = y(n)*y(n)
// pSrcCorr[1] = -2.x(n)*y(n)
// pSrcCorr[2] = z(n)*z(n)
// pSrcCorr[3] = -2.x(n)*z(n)
// pSrcCorr[4] = -2.y(n)*z(n)
// x - target, y - filtered target, z - innovative vectors
// valPredictedGain Input predicted codebook gain.
// pCand pointer to the input pre-searched candidates indexes vector[2].
// pCand[0] from [0,4]
// pCand[1] from [0,8]
//
// pIdxs Pointer to the output indexes vector[2].
// tameProcess Taming process indicator.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsGainCodebookSearch_G729_32f,(const Ipp32f *pSrcCorr,
Ipp32f valPredictedGain, const int *pCand, int *pIdxs, int tameProcess))
IPPAPI(IppStatus, ippsGainCodebookSearch_G729D_32f,(const Ipp32f *pSrcCorr,
Ipp32f valPredictedGain, const int *pCand, int *pIdxs, int tameProcess))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainQuant
// Purpose: Construct of the excitation for the high rate coder by
// MultiPulse Maximum Likelihood Quantization (MP-MLQ) of the residual
// signal
// pImp pointer to the input impulse response of combined filter
// pSrc pointer to the input target vector.
// pDstLoc pointer to the output pulse location
// pDstAmp pointer to the output pulse amplitudes
// pMaxErr pointer to the output maximal error
// pGrid output grid (even = 0, odd = 1)
// pAmp output index of max codebook amplitude
// Np input number of pulses
// isBest shows whether best gain found (1) or not (0)
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsGainQuant_G723_16s, (const Ipp16s *pImp, const Ipp16s *pSrc,
Ipp16s *pDstLoc, Ipp16s *pDstAmp, Ipp32s *pMaxErr, Ipp16s *pGrid, Ipp16s *pAmp,
int Np, int* isBest) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecodeGain
// Purpose: Decode adaptive and fixed-codebook gains
// energy energy of code vector in Q32
// pPastEnergy past quantized energies
// quaIndex pointer to the gain quantization indexes transmitted:
// quaIndex[0] - GA, quaIndex[1] - GB.
// NULL for bad frame
// pGain Pointer to the vector of decoded gains:
// pGain[0] - adaptive and pGain[1] - fixed codebook gains.
// For active frame: output vector.
// For bad (erased) frame - input/output vector.
// Input of gains decoded for previous frame.
// See subclause G.729 3.9.1
// valGainAttenuation
// Attenuation factor for gains. See subclause G.729 E.4.4.3
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsDecodeGain_G729_16s, (Ipp32s energy, Ipp16s *pPastEnergy,
const Ipp16s *quaIndex, Ipp16s *pGain) )
IPPAPI(IppStatus, ippsDecodeGain_G729I_16s, (Ipp32s energy, Ipp16s valGainAttenuation, Ipp16s *pPastEnergy,
const Ipp16s *quaIndex, Ipp16s *pGain))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsTiltCompensation
// Purpose: Tilt compensation filter
// G729: transfer function 1/(1-|mu|) * (1 + mu * 1/z)
// G723: transfer function 1 + 0.25*k1*(1/z)
// pSrc pointer to the input vector
// val gain coefficient
// pDst pointer to the output filtered vector
// pSrcImpulseResponse Pointer to the impulse response hf(n) in the length of 20, in Q12.
// pSrcDstSpch Pointer to the speech x(n), in Q15
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsTiltCompensation_G729E_16s, (Ipp16s val, const Ipp16s *pSrc,
Ipp16s *pDst) )
IPPAPI( IppStatus, ippsTiltCompensation_G723_32s16s, (Ipp16s val, const Ipp32s *pSrc,
Ipp16s *pDst) )
IPPAPI (IppStatus, ippsTiltCompensation_G729_16s,(const Ipp16s * pSrcImpulseResponse,
Ipp16s * pSrcDstSpch))
IPPAPI (IppStatus, ippsTiltCompensation_G729A_16s,
(const Ipp16s * pSrcLPC,Ipp16s * pSrcDstFltResidual))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLongTermPostFilter
// Purpose: Long-term post G729 filtering
// valDelay pitch delay
// gammaFactor the LTP weighting factor
// pSrcSpch Pointer to the resconstructed speech s[n]
// pSrcLPC Pointer to weighted LP coff a'[i]
// pSrcDstResidual Pointer to LP residual signal.
// pDstFltResidual Pointer to output filtered residual signal.
// pResultVoice Pointer to the voice information.
// frameType The type of the frame (1 - active, 2 - SID, 0 - untransmitted).
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLongTermPostFilter_G729_16s,(Ipp16s gammaFactor, int valDelay,
const Ipp16s *pSrcDstResidual, Ipp16s *pDstFltResidual, Ipp16s *pResultVoice ))
IPPAPI(IppStatus, ippsLongTermPostFilter_G729A_16s,(Ipp16s valDelay, const Ipp16s * pSrcSpch,
const Ipp16s * pSrcLPC, Ipp16s * pSrcDstResidual, Ipp16s * pDstFltResidual))
IPPAPI(IppStatus, ippsLongTermPostFilter_G729B_16s,(Ipp16s valDelay, const Ipp16s * pSrcSpch,
const Ipp16s * pSrcLPC, Ipp16s * pSrcDstResidual, Ipp16s * pDstFltResidual,
Ipp16s * pResultVoice, Ipp16s frameType))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsShortTermPostFilter
// Purpose: Short-term post G729 filtering
// pSrcDstSpch Pointer to the short-term filtered speech y(n), in Q15
// pSrcLPC Pointer to the quantized LP coefficients in the length of 11, in Q12
// pDstFltResidual Pointer to the residual signal x(n) in the length of 40, in Q15.
// pDstImpulseResponse Pointer to the generated impulse response hf(n)
// in the length of 20, in Q12..
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsShortTermPostFilter_G729_16s, (const Ipp16s * pSrcLPC,
const Ipp16s * pSrcFltResidual, Ipp16s * pSrcDstSpch, Ipp16s * pDstImpulseResponse))
IPP_DEPRECATED("use ippsSynthesisFilter_NR_16s_Sfs function instead of this one")\
IPPAPI( IppStatus, ippsShortTermPostFilter_G729A_16s,(const Ipp16s * pSrcLPC,
const Ipp16s * pSrcFltResidual,Ipp16s * pSrcDstSpch))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPreemphasize
// Purpose: Preemphasis post filter
// H(z) = 1 - gamma z^-1 (G.729/A)
// H(z) = 1 + gamma z^-1 (GSMAMR)
// pSrcDst pointer to the input/output vector
// gamma filter coeeficient
// pMem pointer to the filter memory of length 1
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsPreemphasize_G729A_16s_I, (Ipp16s gamma, Ipp16s *pSrcDst, int len,
Ipp16s* pMem) )
IPPAPI( IppStatus, ippsPreemphasize_32f_I,(Ipp32f gamma, Ipp32f *pSrcDst, int len,
Ipp32f *pMem))
IPPAPI( IppStatus, ippsPreemphasize_G729A_16s, (Ipp16s gamma, const Ipp16s *pSrc, Ipp16s *pDst,
int len, Ipp16s* pMem) )
IPPAPI( IppStatus, ippsPreemphasize_GSMAMR_16s, (Ipp16s gamma, const Ipp16s *pSrc, Ipp16s *pDst,
int len, Ipp16s* pMem) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainControl
// Purpose: Adaptive gain control
// Compensate for the gain difference between reconstructed speech signal given
// pSrc (sr) and the postfiltered signal given by pSrcDst (spf)
// dst[i] = g[i] * dst[i]
// pSrc pointer to the input vector
// pSrcDst Pointer to the input post-filtered and output gain compensated signal vector.
// pSrcDstGain the gain for the previous subframe
// pGain the gain for the previous subframe
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsGainControl_G729_16s_I, (const Ipp16s *pSrc1, Ipp16s *pSrcDst,
Ipp16s *pGain) )
IPPAPI( IppStatus, ippsGainControl_G729A_16s_I, (const Ipp16s *pSrc1, Ipp16s *pSrcDst,
Ipp16s *pGain) )
IPPAPI( IppStatus, ippsGainControl_G723_16s_I, (Ipp32s energy, Ipp16s *pSrcDst, Ipp16s *pGain) )
IPPAPI( IppStatus, ippsGainControl_G729_32f_I,(Ipp32f gainScalingVal,
Ipp32f gainFactor, Ipp32f *pSrcDst, Ipp32f *pGain))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRandomNoiseExcitation
// Purpose: Generation of random noise excitation
// gain target sample gain
// pSrcDst pointer to the input/output excitation vector
// pSeed pointer to the input/output seed for the random generator
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsRandomNoiseExcitation_G729B_16s, (Ipp16s *pSeed, Ipp16s *pExc, int len) )
IPPAPI( IppStatus, ippsRandomNoiseExcitation_G729B_16s32f,(Ipp16s *pSeed, Ipp32f *pExc, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLPCLevinsonDurbin
// Purpose: Obtaining of the LPC
// G.729: filter 1/1-A(z), LPC in Q12, by solving the set of equation
// SUM(i=1,order)a(i)*r(|i-k|) = -r(k) k=1,..,order
// Parameters:
// pSrcAutoCorr pointer to the autocorrelation vector [order+1]
// order LP order
// pDstLPC pointer to the LPC output vector [order+1]
// pDstRC pointer to the RC output vector
// [2] - ippsLevinsonDurbin_G729B
// [order+1] - ippsLevinsonDurbin_G729
// pResultResidualEnergy pointer to output residual energy in Q15
//
*/
IPPAPI(IppStatus,ippsLevinsonDurbin_G729_32s16s,( const Ipp32s * pSrcAutoCorr,
int order, Ipp16s * pDstLPC, Ipp16s * pDstRc, Ipp16s * pResultResidualEnergy))
IPPAPI(IppStatus, ippsLevinsonDurbin_G729_32f,(const Ipp32f * pSrcAutoCorr,
int order, Ipp32f * pDstLpc, Ipp32f * pDstRc, Ipp32f * pResultResidualEnergy))
IPPAPI(IppStatus,ippsLevinsonDurbin_G729B,(const Ipp32s * pSrcAutoCorr,
Ipp16s * pDstLPC, Ipp16s * pDstRc, Ipp16s * pResultResidualEnergy))
IPPAPI(IppStatus, ippsLevinsonDurbin_G723_16s,
(const Ipp16s * pSrcAutoCorr, Ipp16s * pValResultSineDtct,
Ipp16s * pResultResidualEnergy, Ipp16s * pDstLPC))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsIIR16s
//
// Purpose: IIR filter
// 1-A(1/z)/1-B(1/z)
// pCoeffs pointer to the input filter coefficients
// pSrc pointer to the input speech vector
// pDst pointer to the output perceptually weighted speech vector
// pMem pointer to the filter memory
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsIIR16sLow_G729_16s,
(const Ipp16s *pCoeffs, const Ipp16s *pSrc, Ipp16s *pDst, Ipp16s *pMem))
IPPAPI (IppStatus, ippsIIR16s_G729_16s,
(const Ipp16s *pCoeffs, const Ipp16s *pSrc, Ipp16s *pDst, Ipp16s *pMem))
IPPAPI( IppStatus, ippsIIR16s_G723_16s32s, (const Ipp16s *pCoeffs, const Ipp16s *pSrc,
Ipp32s *pDst, Ipp16s *pMem ) )
IPPAPI( IppStatus, ippsIIR16s_G723_16s_I, (const Ipp16s *pCoeffs, Ipp16s *pSrcDst,
Ipp16s *pMem ) )
IPPAPI( IppStatus, ippsIIR16s_G723_32s16s_Sfs, (const Ipp16s *pCoeffs, const Ipp32s *pSrc,
int sFs, Ipp16s *pDst, Ipp16s *pMem ) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHarmonicNoiseSubtract_G723_16s_I
//
// Purpose: Do harmonic noise filtering and subtract the result
// from harmonic noise weighted vector
// val the input filter coefficient
// T the input filter lag
// pSrc pointer to the input vector to filter
// pSrcDst pointer to the input/output harmonic noise weighted vector
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsHarmonicNoiseSubtract_G723_16s_I, (Ipp16s val, int T, const Ipp16s *pSrc,
Ipp16s *pSrcDst) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: PhaseDispersion
// Purpose: The filter alters (mainly the phase of) the innovation signal such
// that a new innovation is created which has the energy more spread over
// the subframe. The filtering is performed by circular convolution
// using one of the three stored "semi-random" impulse responses,
// correspond to different amounts of spreading.
// Parameters:
// valPitchGain pitch gain Q14
// valCodebookGain codebook gain Q1
// pSrcExcSignal input signal
// pDstFltExcSignal output signal
// pSrcDstInnovation input/output innovation vector
*/
#if !defined( _OWN_BLDPCS )
typedef struct _PhaseDispersion_State_G729D IppsPhaseDispersion_State_G729D;
#endif
IPPAPI(IppStatus, ippsPhaseDispersionGetStateSize_G729D_16s,(int *pSize))
IPPAPI(IppStatus, ippsPhaseDispersionInit_G729D_16s,(IppsPhaseDispersion_State_G729D *pPhDMem))
IPPAPI(IppStatus, ippsPhaseDispersionUpdate_G729D_16s,(
Ipp16s valPitchGain,
Ipp16s valCodebookGain,
IppsPhaseDispersion_State_G729D *pPhDMem
))
IPPAPI(IppStatus, ippsPhaseDispersion_G729D_16s,(
const Ipp16s *pSrcExcSignal,
Ipp16s *pDstFltExcSignal,
Ipp16s valCodebookGain,
Ipp16s valPitchGain,
Ipp16s *pSrcDstInnovation,
IppsPhaseDispersion_State_G729D *pPhDMem
))
/* ///////////////////////////////////////////////////////////////////////////////////////
// Name: ippsWinHybrid_G729E
// Purpose: Hybrid window auto-correlation for backward-adaptive analysis.
// Window is as follows:
// s(M-N),s(M-N+1),...,s(M-1),s(M),s(M+1),...,s(M+L-1)
// M LPC order for backward adaptation
// L number of signal samples in backward adaptation
// N number of non-recursive samples in the hybrid window
// where pSrcSfs[i] is the scale factor of pSrc[i*DIM],...,pSrc[i*DIM+DIM-1]
//
// pSrcSynthSpeech input signal for backward-adaptive analysis (35 samples)
//
*/
#if !defined( _OWN_BLDPCS )
typedef struct _WinHybridState_G729E_16s IppsWinHybridState_G729E_16s;
typedef struct _WinHybridState_G729E_32f IppsWinHybridState_G729E_32f;
#endif
IPPAPI(IppStatus, ippsWinHybridGetStateSize_G729E_16s,(int *pSize))
IPPAPI(IppStatus, ippsWinHybridGetStateSize_G729E_32f,(int *pSize))
IPPAPI(IppStatus, ippsWinHybridInit_G729E_16s,(IppsWinHybridState_G729E_16s *pMem))
IPPAPI(IppStatus, ippsWinHybridInit_G729E_32f,(IppsWinHybridState_G729E_32f *pMem))
IPPAPI(IppStatus, ippsWinHybrid_G729E_16s32s,(const Ipp16s *pSrcSynthSpeech,
Ipp32s *pDstInvAutoCorr, IppsWinHybridState_G729E_16s *pMem))
IPPAPI(IppStatus, ippsWinHybrid_G729E_32f,(const Ipp32f *pSrcSynthSpeech,
Ipp32f *pDstInvAutoCorr, IppsWinHybridState_G729E_32f *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsAutoCorr_G729B
// Purpose: Apply window and then compute autocorelation of input speech
// Equivalent to:
// ippsMul_NR_16s_Sfs
// ippsAutoCorr_NormE_16s32s
*/
IPPAPI(IppStatus,ippsAutoCorr_G729B,
(const Ipp16s* pSrcSpch, Ipp16s* pResultAutoCorrExp, Ipp32s* pDstAutoCorr))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsLPCToLSP_G729, ippsLPCToLSP_G729A
// Purpose: LP to LSP coefficients conversion
*/
IPPAPI( IppStatus, ippsLPCToLSP_G729_16s,
(const Ipp16s* pSrcLPC, const Ipp16s* pSrcPrevLsp, Ipp16s* pDstLSP) )
IPPAPI( IppStatus, ippsLPCToLSP_G729A_16s,
(const Ipp16s* pSrcLPC, const Ipp16s* pSrcPrevLsp, Ipp16s* pDstLSP) )
IPPAPI( IppStatus, ippsLPCToLSP_G729_32f,
(const Ipp32f* pSrcLPC, const Ipp32f* pSrcPrevLsp, Ipp32f* pDstLSP))
IPPAPI( IppStatus, ippsLPCToLSP_G729A_32f,
(const Ipp32f* pSrcLPC, const Ipp32f* pSrcPrevLsp, Ipp32f* pDstLSP))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsAdaptiveCodebookSearch_G729_16s
// Purpose: Determination of optimal integer and fractional pitch delay
// and generation of adaptive codebook vector
// Parameters:
// valOpenDelay Open-loop delay, in the range [18,145].
// pSrcAdptTarget Pointer to the target signal for adaptive-codebook
// search vector [40].
// pSrcImpulseResponse Pointer to the impulse response of weighted synthesis filter
// vector [40]
// pSrcDstPrevExcitation Pointer to the previous and updated excitation vector [194].
// pDstDelay Pointer to the integer delay and fraction delay vector [2].
// pDstAdptVector Pointer to the adaptive vector [40].
// subFrame Subframe number, either 0 or 1.*/
IPPAPI( IppStatus, ippsAdaptiveCodebookSearch_G729_16s, (Ipp16s valOpenDelay,
const Ipp16s * pSrcAdptTarget, const Ipp16s * pSrcImpulseResponse,
Ipp16s * pSrcDstPrevExcitation, Ipp16s * pDstDelay,
Ipp16s * pDstAdptVector, Ipp16s subFrame))
IPPAPI( IppStatus, ippsAdaptiveCodebookSearch_G729A_16s, (Ipp16s valOpenDelay,
const Ipp16s * pSrcAdptTarget, const Ipp16s * pSrcImpulseResponse,
Ipp16s * pSrcDstPrevExcitation, Ipp16s * pDstDelay,
Ipp16s * pDstAdptVector, Ipp16s subFrame))
IPPAPI( IppStatus, ippsAdaptiveCodebookSearch_G729D_16s, (Ipp16s valOpenDelay,
const Ipp16s * pSrcAdptTarget, const Ipp16s * pSrcImpulseResponse,
Ipp16s * pSrcDstPrevExcitation, Ipp16s subFrame, Ipp16s * pDstDelay ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilteredExcitation_G729
// Purpose: computes filtered excitation
// Arguments:
// pSrcImpulseResponse Pointer to the impulse response of weighted synthesis filter
// vector
// pSrcDstPrevExcitation Pointer to the previous and updated excitation vector [194].
// valExc Excitation value delayed by pitch lag ( u(-k) )
// len Length of input/output vectors
*/
IPPAPI(IppStatus, ippsFilteredExcitation_G729_32f,
( const Ipp32f* pSrcImpulseResponse, Ipp32f *pSrcDstPrevExcitation, int len, Ipp32f valExc))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsLSPQuant_G729_16s
// Purpose: LSP quantization
// Is equivalent to:
// ippsLSPToLSF_G729_16s
// ippsLSFQuant_G729_16s
// ippsLSFToLSP_G729_16s
*/
IPPAPI( IppStatus, ippsLSPQuant_G729_16s, (const Ipp16s * pSrcLsp, Ipp16s * pSrcDstPrevFreq,
Ipp16s * pDstQLsp, Ipp16s * pDstQLspIndex))
IPPAPI (IppStatus, ippsLSPQuant_G729E_16s, (const Ipp16s * pSrcLsp, const Ipp16s * pSrcPrevFreq,
Ipp16s * pDstQLsf, Ipp16s * pDstQLsp, Ipp16s * pDstQLspIndex))
IPPAPI (IppStatus, ippsLSPQuant_G729E_32f, (const Ipp32f *pSrcLsp, Ipp32f* pSrcDstPrevFreq, Ipp32f *pDstQLsf,
Ipp32f *pDstQLsp, int *pDstQLspIndex) )
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsAdaptiveCodebookGain_G729_16s
// Purpose: Compute the adaptive codebook gain
//
// pSrcImpulseResponse: Pointer to the impulse response
// of the perceptual weighting filter in the length of 40, in Q12.
// pSrcAdptVector: Pointer to the adaptive-codebook vector in the length of 40.
// pSrcLPC: Pointer to the LPC coefficients of the synthesis filter
// in the length of 11, in Q12.
// pDstFltAdptVector: Pointer to the output filtered adaptive-codebook vector
// pSrcFltAdptVector: Pointer to the input filtered adaptive-codebook vector
// in the length of 40.
// pResultAdptGain: Pointer to the adaptive-codebook gain in the length of 1, in Q14.
// pResultAdptGainCoeffs Pointer to the output vector in the length 4 represents
// the adaptive-codebook gain as a fraction:
// xy * 2^exp_xy
// gain = ------------- in Q14
// yy * 2^exp_yy
// where yy = pResultAdptGainCoeffs[0]
// exp_yy = pResultAdptGainCoeffs[1]
// exp_xy = pResultAdptGainCoeffs[2]
// exp_xy = pResultAdptGainCoeffs[3]
// If xy < 4 then gain = 0;
*/
IPPAPI( IppStatus, ippsAdaptiveCodebookGain_G729_16s, (const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcImpulseResponse, const Ipp16s * pSrcAdptVector,
Ipp16s * pDstFltAdptVector, Ipp16s * pResultAdptGain))
IPPAPI( IppStatus, ippsAdaptiveCodebookGain_G729A_16s, (const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcLPC, const Ipp16s * pSrcAdptVector, Ipp16s * pDstFltAdptVector,
Ipp16s * pResultAdptGain))
IPPAPI( IppStatus, ippsAdaptiveCodebookGain_GSMAMR_16s,(const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcFltAdptVector, Ipp16s * pResultAdptGain))
IPPAPI( IppStatus, ippsAdaptiveCodebookGainCoeffs_GSMAMR_16s,(const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcFltAdptVector, Ipp16s * pResultAdptGain,
Ipp16s * pResultAdptGainCoeffs))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsFFTFwd_RToPerm_GSMAMR_16s
// Purpose: This is an implementation of decimation-in-time FFT algorithm for
// real sequences.
// pSrcDst pointer to the input signal/output frequencies vector in Perm format
*/
IPPAPI( IppStatus, ippsFFTFwd_RToPerm_GSMAMR_16s_I, (Ipp16s *pSrcDst))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsAutoCorr_G723_16s
// Purpose: Apply window and then compute autocorelation of input speech
// Equivalent to:
// ippsAutoScale_16s
// ippsMul_NR_16s_ISfs
// ippsAutoCorr_NormE_G723_16s
*/
IPPAPI(IppStatus, ippsAutoCorr_G723_16s,(const Ipp16s * pSrcSpch,
Ipp16s * pResultAutoCorrExp, Ipp16s * pDstAutoCorr))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLPCToLSF_G723_16s
// Purpose: LSP to LSF conversion normalized
// pLSF[i] = arccos(pLSP[i]); i=0,...,10
// pSrcLPC pointer to the LPC input vector
// pSrcPrevLSF pointer to previous normalized LSF coefficients
// pDstLSF pointer to the LSF output vector of values 15 bit scaled in range [0:0.5]
// Parameters:
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsLPCToLSF_G723_16s,(const Ipp16s * pSrcLPC,
const Ipp16s * pSrcPrevLSF, Ipp16s * pDstLSF))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHarmonicSearch_G723_16s
// Purpose: This function searches the harmonic delay and harmonic gain for the harmonic noise shaping filter
// from the weighted speech and open loop pitch.
// valOpenDelay Open loop pitch
// pSrcWgtSpch Pointer to the weighted speech in the length of 205. The pointer points to the
// location of 146
// pResultHarmonicDelay Pointer to the harmonic delay
// pResultHarmonicGain Pointer to the harmonic gain
// Parameters:
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsHarmonicSearch_G723_16s,(Ipp16s valOpenDelay, const Ipp16s * pSrcWgtSpch,
Ipp16s * pResultHarmonicDelay, Ipp16s * pResultHarmonicGain))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookSearch_G723
// Purpose: This function searches for the close loop pitch and adaptive gain index.
// valBaseDelay Base delay
// pSrcAdptTarget Pointer to the adaptive target signal in the length of 60.
// pSrcImpulseResponse Pointer to the impulse response in the length of 60.
// pSrcPrevExcitation Pointer to the previous excitation in the length of 145.
// pSrcPrevError Pointer to the previous error in the length of 5, in 32-bit format.
// pResultCloseLag Pointer to the lag of close pitch
// pResultAdptGainIndex Pointer to the index of adaptive gain
// subFrame Subframe number
// sineDtct Sine circumstance.
// bitRate Transmit bit rate
// Parameters:
// Returns: ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsAdaptiveCodebookSearch_G723,(
Ipp16s valBaseDelay,
const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcImpulseResponse,
const Ipp16s * pSrcPrevExcitation,
const Ipp32s * pSrcPrevError,
Ipp16s * pResultCloseLag,
Ipp16s * pResultAdptGainIndex,
Ipp16s subFrame,
Ipp16s sineDtct,
IppSpchBitRate bitRate))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecodeAdaptiveVector_G723_16s
// Purpose: This function decodes the adaptive vector from excitation,
// close loop pitch, adaptive gain index and bit rate.
*/
IPPAPI (IppStatus, ippsDecodeAdaptiveVector_G723_16s,(
Ipp16s valBaseDelay,
Ipp16s valCloseLag,
Ipp16s valAdptGainIndex,
const Ipp16s * pSrcPrevExcitation,
Ipp16s * pDstAdptVector,
IppSpchBitRate bitRate))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSFToLPC_G723_16s
// Purpose: This function converts a set of 10-order LSF coefficients to LPC coefficients.
// Equivalent to:
// ippsLSFToLPC_G723_16s_I
*/
IPPAPI (IppStatus, ippsLSFToLPC_G723_16s,(const Ipp16s * pSrcLSF, Ipp16s * pDstLPC))
IPPAPI( IppStatus, ippsLSFToLPC_G723_16s_I, (Ipp16s *pLSFLPC) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSFQuant_G723_16s32s
// Purpose: This function searches for the close loop pitch and adaptive gain index.
// pSrcLSF Pointer to LSF coefficients
// pSrcPrevLSF Pointer to previous LSF coefficients
// pResultQLSFIndex Pointer to combined index of quantized LSF coefficients.
// Parameters:
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsLSFQuant_G723_16s32s,(const Ipp16s * pSrcLSF, const Ipp16s *pSrcPrevLSF,
Ipp32s * pResultQLSFIndex))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsACELPFixedCodebookSearch_G723_16s
// Purpose: TThis function searches for the ACELP fixed codebook for the excitation for 5.3 Kbps bit rate.
// Equivalent to:
// ippsFixedCodebookSearch_G723_16s
*/
IPPAPI (IppStatus, ippsACELPFixedCodebookSearch_G723_16s,(
const Ipp16s * pSrcFixedCorr,
const Ipp16s * pSrcMatrix,
Ipp16s * pDstFixedSign,
Ipp16s * pDstFixedPosition,
Ipp16s * pResultGrid,
Ipp16s * pDstFixedVector,
Ipp16s * pSearchTimes))
IPPAPI( IppStatus, ippsACELPFixedCodebookSearch_G723_32s16s,(
const Ipp16s * pSrcFixedCorr,
Ipp32s * pSrcDstMatrix,
Ipp16s * pDstFixedSign,
Ipp16s * pDstFixedPosition,
Ipp16s * pResultGrid,
Ipp16s * pDstFixedVector,
Ipp16s * pSearchTimes))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMPMLQFixedCodebookSearch_G723
//
// Purpose: This function searches for the MP-MLQ fixed-codebook for the excitation for 6.3Kbps bit rate.
// valBaseDelay - Base delay, in Q0.
// pSrcImpulseResponse - Pointer to the impulse response in the length of 60.
// pSrcResidualTarget - Pointer to the residue target signal in the length of 60.
// pDstFixedVector - Pointer to the fixed codebook vector in the length of 60.
// pResultGrid - Pointer to the begin grid location, in Q0, 0 or 1.
// pResultTrainDirac - Pointer to the flag if train Dirac function used, 0: unused, 1: used.
// pResultAmpIndex - Pointer to the index of quantized amplitude, in Q0.
// pResultAmplitude - Pointer to the amplitude of the fixed codebook vector.
// pResultPosition - Pointer to the position of fixed codebook vector, which amplitude is not equal
// to 0, in Q0.
// subFrame - Subframe number, in Q0, from 0 to 3.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsMPMLQFixedCodebookSearch_G723,(
Ipp16s valBaseDelay,
const Ipp16s * pSrcImpulseResponse,
const Ipp16s * pSrcResidualTarget,
Ipp16s * pDstFixedVector,
Ipp16s * pResultGrid,
Ipp16s * pResultTrainDirac,
Ipp16s * pResultAmpIndex,
Ipp16s * pResultAmplitude,
Ipp32s * pResultPosition,
Ipp16s subFrame))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSynthesisFilter_G723_16s
//
// Purpose: function implements the LPC synthesis filter.
// pSrcLPC - Pointer to the LPC coefficients in the length of 10, in Q13.
// pSrcResidual - Pointer to the residual signal in the length of 60.
// pSrcDstIIRState - Pointer to the history of synthesized speech signal in the
// length of 10.
// pDstSpch - Pointer to the output speech signal in the length of 60.
// pMem pointer to the filter memory
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsSynthesisFilter_G723_16s32s, (const Ipp16s *pQntLPC, const Ipp16s *pSrc,
Ipp32s *pDst, Ipp16s *pMem ) )
IPPAPI(IppStatus, ippsSynthesisFilter_G723_16s, (const Ipp16s *pSrcLPC, const Ipp16s *pSrcResidual,
Ipp16s *pSrcDstIIRState, Ipp16s *pDstSpch))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPitchPostFilter_G723_16s
//
// Purpose: function calculates the coefficients of the pitch post filter..
// valBaseDelay - Base delay, in Q0.
// pSrcResidual - Pointer to the residual signal in the length of 365.
// The pointer points to the location of 146.
// subFrame - Subframe number, in Q0, from 0 to 3.
// bitRate - Transmit bit rate, IPP_SPCHBR_6300 stands for 6.3 Kbps
// and IPP_SPCHBR_5300 stands for 5.3 Kbps.
// pResultDelay - Point to the delay of the pitch post filter, in Q0.
// pResultPitchGain - Point to the gain of the pitch post filter, in Q15.
// pResultScalingGain - Point to the scaling gain of the pitch post filter, in Q15.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsPitchPostFilter_G723_16s, (Ipp16s valBaseDelay, const Ipp16s *pSrcResidual,
Ipp16s *pResultDelay, Ipp16s *pResultPitchGain, Ipp16s *pResultScalingGain,
Ipp16s subFrame, IppSpchBitRate bitRate))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAutoCorr_GSMAMR_16s32s
//
// Purpose: Compute autocorrelations of signal with windowing and
// Lag windowing
// pSrcSpch - Pointer to the input speech vector (240 samples),
// represented using Q15.0.
// mode - Bit rate specifier. Values between IPP_SPCHBR_4750 and
// IPP_SPCHBR_12200 are valid.
// pDstAutoCorr - Pointer to the autocorrelation coefficients, of length 22.
// For 12.2 kbps mode, elements 0 ~ 10 contain the first
// set of autocorrelation lags, and elements 11 ~ 21
// contain the second set of autocorrelation lags.
// For all other modes there is only one set of autocorrelation
// lags contained in vector elements 0 ~ 10.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAutoCorr_GSMAMR_16s32s,
(const Ipp16s *pSrcSpch, Ipp32s *pDstAutoCorr,IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLevinsonDurbin_GSMAMR_32s16s
//
// Purpose: Calculates the 10th-order LP coefficients from the autocorrelation lags using the Levinson-Durbin
// algorithm.
// pSrcAutoCorr - Pointer to the autocorrelation coefficients, a vector of length of 11.
// pSrcDstLPC - Pointer to the LP coefficients associated with
// the previous frame, a vector of length 11, represented using Q3.12.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLevinsonDurbin_GSMAMR_32s16s,
(const Ipp32s *pSrcAutoCorr, Ipp16s *pSrcDstLPC))
#define ippsLevinsonDurbin_GSMAMR ippsLevinsonDurbin_GSMAMR_32s16s
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLPCToLSP_GSMAMR_16s
//
// Purpose: Converts a set of 10th-order LP coefficients to
// an equivalent set of line spectrum pairs (LSPs).
// pSrcLPC - Pointer to 11-element LP coefficient vector, represented using Q3.12.
// pSrcPrevLsp - Pointer to the 10-element LSP coefficient vector associated
// with the previous frame, represented using Q0.15.
// pDstLsp - Pointer to the 10-element LSP coefficient vector, represented using Q0.15.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLPCToLSP_GSMAMR_16s,
(const Ipp16s * pSrcLPC, const Ipp16s * pSrcPrevLsp, Ipp16s * pDstLsp))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSPToLPC_GSMAMR_16s
//
// Purpose: Converts a set of 10th-order LSPs to LP coefficients.
// pSrcLsp - Pointer to the 10-element LSP coefficient vector, represented using Q0.15.
// pDstLPC - Pointer to the 11-element LP coefficient vector, represented using Q3.12.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLSPToLPC_GSMAMR_16s, (const Ipp16s *pSrcLsp, Ipp16s *pDstLPC))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSPQuant_GSMAMR_16s
//
// Purpose: Quantizes the LSP coefficient vector, then obtains quantized LSP codebook indices.
// pSrcLsp - Pointer to the unquantized 20-element LSP vector, represented using Q0.15. For
// 12.2 kbps frames, the first LSP set is contained in vector elements 0 ~ 9, and the second LSP
// set is contained in vector elements 10 ~ 19. For all other bit rates, only elements 0 ~ 9 are valid
// and used for the quantization.
// pSrcDstPrevQLSFResidual - Pointer to the 10-element quantized LSF residual from the previous
// frame, represented using Q0.15.
// pDstQLsp - Pointer to the 20-element quantized LSP vector, represented using Q0.15. For 12.2
// kbps frames, elements 0 to 9 contain the first quantized LSP set, and elements 10 to 19 contain
// the second quantized LSP set. For all other bit rates there is only one LSP set contained in
// elements 0 to 9.
// pDstQLspIndex - Pointer to the 5-element vector of quantized LSP indices. For 12.2Kbps
// frames, all five elements contain valid data; for all other bit rates, only the first three elements
// contain valid indices.
// mode - Bit rate specifier. The enumerated values of IPP_SPCHBR_4750 to
// IPP_SPCHBR_12200 are valid.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLSPQuant_GSMAMR_16s, (const Ipp16s *pSrcLsp,
Ipp16s *pSrcDstPrevQLSFResidual, Ipp16s *pDstQLsp,
Ipp16s *pDstQLspIndex, IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncDTXSID_GSMAMR_16s
//
// Purpose: This function is called only when the current frame is a DTX frame. It extracts the needed
// parameters for the SID frame: LSF quantization parameter and the energy index parameter. If the
// SID flag is off, no operation is needed, and all the parameters are copied from last frame.
// pSrcLspBuffer - Pointer to the LSP coefficients of eight consecutive frames marked with
// VAD = 0, in the length of 80, in Q15.
// pSrcLogEnergyBuffer - Pointer to the log energy coefficients of eight consecutive frames
// marked with unvoiced, in the length of 8, in Q10.
// pValResultLogEnergyIndex - Pointer log energy index of last frame, in Q2.
// pValResultDtxLSFRefIndex - Pointer to the LSF quantization reference index of last frame.
// pSrcDstDtxQLSFIndex - Pointer to the LSF residual quantization indices of last frame, in the
// length of 3.
// pSrcDstPredQErr - Pointer to the fixed gain prediction error of four previous subframes for
// non-12.2 Kbps modes, in the length of 4, in Q10.
// pSrcDstPredQErrMR122 - Pointer to the fixed gain prediction error of four previous
// subframes for 12.2 Kbps, in the length of 4, in Q10.
// sidFLag - The SID flag of the current frame. If it is set to 1, the current frame is a SID frame,
// and the function will extract the LSF and energy parameters. If it is set to 0, the LSF and
// energy parameters will copy from previous frame.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsEncDTXSID_GSMAMR_16s, (const Ipp16s *pSrcLspBuffer,
const Ipp16s *pSrcLogEnergyBuffer, Ipp16s *pValResultLogEnergyIndex,
Ipp16s *pValResultDtxLSFRefIndex, Ipp16s *pSrcDstDtxQLSFIndex,
Ipp16s *pSrcDstPredQErr, Ipp16s *pSrcDstPredQErrMR122,
Ipp16s sidFlag))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQuantLSPDecode_GSMAMR_16s
//
// Purpose: Decodes quantized LSPs from the received codebook index if the
// errors are not detected on the received frame. Otherwise, the
// function recovers the quantized LSPs from previous quantized
// LSPs using linear interpolation.
// pSrcQLspIndex - Pointer to the five-element vector containing codebook indices
// of the quantized LSPs.
// pSrcDstPrevQLSFResidual - Pointer to the 10-element quantized LSF residual from
// the previous frame, represented using Q0.15.
// pSrcDstPrevQLSF - Pointer to the 10-element quantized LSF vector from the previous
// frame, represented using Q0.15.
// pSrcDstPrevQLsp - Pointer to the 10-element quantized LSP vector from the previous
// frame, represented using Q0.15.
// pDstQLsp - Pointer to a 40-element vector containing four subframe LSP sets.
// bfi - Bad frame indicator; "0" signifies a good frame; all other values
// signify a bad frame.
// mode - Bit rate specifier.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsQuantLSPDecode_GSMAMR_16s, (const Ipp16s *pSrcQLspIndex,
Ipp16s *pSrcDstPrevQLSFResidual, Ipp16s *pSrcDstPrevQLSF,
Ipp16s *pSrcDstPrevQLsp, Ipp16s *pDstQLsp, Ipp16s bfi,
IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncDTXHandler_GSMAMR_16s
//
// Purpose: Function determines the SID flag of current frame, and it determines
// whether the current frame should use DTX encoding.
// pValResultHangOverCount - Pointer to the DTX hangover count. When initialized or reset,
// it is set to 0.
// pValResultDtxElaspCount - Pointer to elapsed frame count since last non-DTX frame.
// When initialized or reset, it is set 0.
// pValResultUsedMode - Pointer to the transmission mode.
// pResultSidFlag - Pointer to the output SID flag, "1" indicates a SID frame, and "0"
// indicates a non-SID frame.
// vadFlag - This is the VAD flag of the current frame, if it is set 1, the current
// frame is marked with voiced, and if it is set to 0, it is marked with
// unvoiced.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsEncDTXHandler_GSMAMR_16s, (Ipp16s *pValResultHangOverCount,
Ipp16s *pValResultDtxElapseCount, Ipp16s *pValResultUsedMode,
Ipp16s *pResultSidFlag, Ipp16s vadFlag))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncDTXBuffer_GSMAMR_16s
//
// Purpose: Function buffer the LSP coefficients and previous log energy coefficients.
// pSrcSpch - Pointer to the input speech signal, in the length of 160, in Q15.0.
// pSrcLsp - Pointer to the LSP for this frame, in the length of 10, in Q0.15.
// pValResultUpdateIndex - Pointer to the previous memory update index. It is a value
// circularly increased between 0 and 7.
// pSrcDstLspBuffer - Pointer to the LSP coefficients of eight previous frames, in the
// length of 80, in Q0.15.
// pSrcDstLogEnergyBuffer - Pointer to the logarithm energy coefficients of eight previous
// frames,inthelength of 8,in Q5.10.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsEncDTXBuffer_GSMAMR_16s, (const Ipp16s * pSrcSpch,
const Ipp16s *pSrcLsp, Ipp16s *pValResultUpdateIndex,
Ipp16s *pSrcDstLspBuffer, Ipp16s *pSrcDstLogEnergyBuffer))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecDTXBuffer_GSMAMR_16s
//
// Purpose: Function buffer the LSF coefficients and previous log energy coefficients.
// pSrcSpch - Pointer to the input speech signal, in the length of 160, in Q15.0.
// pSrcLSF - Pointer to the LSF for this frame, in the length of 10, in Q0.15.
// pValResultUpdateIndex - Pointer to the previous memory update index. It is a value
// circularly increased between 0 and 7.
// pSrcDstLSFBuffer - Pointer to the LSF coefficients of eight previous frames, in the
// length of 80, in Q0.15.
// pSrcDstLogEnergyBuffer - Pointer to the logarithm energy coefficients of eight previous
// frames,inthelength of 8,in Q5.10.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsDecDTXBuffer_GSMAMR_16s, (const Ipp16s *pSrcSpch,
const Ipp16s *pSrcLSF, Ipp16s *pValResultUpdateIndex,
Ipp16s *pSrcDstLSFBuffer, Ipp16s *pSrcDstLogEnergyBuffer))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAlgebraicCodebookSearch_GSMAMR_16s
//
// Purpose: Fixed (algebraic) codebook search functions
// valIntPitchLag pitch lag
// valBoundQAdptGain pitch gain
// pSrcFixedTarget target vector
// pSrcLtpResidual long term prediction residual
// pSrcDstImpulseResponse impulse response of weighted synthesis
// filter h[-L_subfr..-1] must be set to zero
// pDstFixedVector innovative codebook
// pDstFltFixedVector filtered fixed codebook excitation
// pDstEncPosSign signs of the pulses
// subFrame subframe number
// mode coder mode
// pBuffer pointer to the internal memory buffer
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsAlgebraicCodebookSearch_GSMAMR_16s, (Ipp16s valIntPitchLag, Ipp16s valBoundQAdptGain,
const Ipp16s *pSrcFixedTarget, const Ipp16s *pSrcLtpResidual, Ipp16s *pSrcDstImpulseResponse,
Ipp16s *pDstFixedVector, Ipp16s *pDstFltFixedVector, Ipp16s *pDstEncPosSign,
Ipp16s subFrame, IppSpchBitRate mode) )
IPPAPI(IppStatus, ippsAlgebraicCodebookSearchEX_GSMAMR_16s,
(Ipp16s valIntPitchLag, Ipp16s valBoundQAdptGain,
const Ipp16s * pSrcFixedTarget, const Ipp16s * pSrcLtpResidual,
Ipp16s * pSrcDstImpulseResponse, Ipp16s * pDstFixedVector,
Ipp16s * pDstFltFixedVector, Ipp16s * pDstEncPosSign,
Ipp16s subFrame, IppSpchBitRate mode, Ipp32s * pBuffer))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFixedCodebookDecode_GSMAMR_16s
//
// Purpose: Fixed codebook vector decode functions
// pSrcFixedIndex pointer to the fixed codebook index vector
// pDstFixedVector pointer to the 40-element fixed codebook vector
// subFrame subframe number
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsFixedCodebookDecode_GSMAMR_16s,
(const Ipp16s *pSrcFixedIndex,
Ipp16s *pDstFixedVector,
Ipp16s subFrame,
IppSpchBitRate mode) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsOpenLoopPitchSearchNonDTX_GSMAMR_16s
//
// Purpose: Computes the open-loop pitch lag (as well as optimal pitch gain for 10.2 kbps frames only) when
// both DTX and VAD are disabled.
// pSrcWgtLPC1 Pointer to the 44-element vector of weighted LP coefficients
// pSrcWgtLPC2 Pointer to the 44-element vector of weighted LP coefficients
// pSrcSpch Pointer to the 170-sample input speech vector
// pValResultPrevMidPitchLag Pointer to the median filtered pitch lag of the 5 previous voiced
// speech half-frames
// pValResultVvalue Pointer to the adaptive parameter v
// pSrcDstPrevPitchLag Pointer to the five-element vector that contains the pitch lags associated
// with the five most recent voiced speech half-frames
// pSrcDstPrevWgtSpch Pointer to a 143-element vector containing perceptually weighted
// speech from the previous frame
// pDstOpenLoopLag Pointer to a two-element vector of open-loop pitch lags.
// pDstOpenLoopGain Pointer to a 2-element vector containing optimal open-loop pitch gains.
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsOpenLoopPitchSearchNonDTX_GSMAMR_16s,(
const Ipp16s * pSrcWgtLPC1,
const Ipp16s * pSrcWgtLPC2,
const Ipp16s * pSrcSpch,
Ipp16s * pValResultPrevMidPitchLag,
Ipp16s * pValResultVvalue,
Ipp16s * pSrcDstPrevPitchLag,
Ipp16s * pSrcDstPrevWgtSpch,
Ipp16s * pDstOpenLoopLag,
Ipp16s * pDstOpenLoopGain,
IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsOpenLoopPitchSearchDTXVAD1_GSMAMR_16s
//
// Purpose: Extracts an open-loop pitch lag estimate from the weighted input speech when the VAD 1 scheme
// is enabled
// pSrcWgtLPC1 Pointer to the 44-element vector of weighted LP coefficients
// pSrcWgtLPC2 Pointer to the 44-element vector of weighted LP coefficients
// pSrcSpch Pointer to the 170-sample input speech vector
// pValResultToneFlag Pointer to the tone flag for the VAD module.
// pValResultPrevMidPitchLag Pointer to the median filtered pitch lag of the 5 previous voiced
// speech half-frames
// pValResultVvalue Pointer to the adaptive parameter v
// pSrcDstPrevPitchLag Pointer to the five-element vector that contains the pitch lags associated
// with the five most recent voiced speech half-frames
// pSrcDstPrevWgtSpch Pointer to a 143-element vector containing perceptually weighted
// speech from the previous frame
// pResultMaxHpCorr Pointer to the correlation maximum.
// pDstOpenLoopLag Pointer to a two-element vector of open-loop pitch lags.
// pDstOpenLoopGain Pointer to a 2-element vector containing optimal open-loop pitch gains.
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsOpenLoopPitchSearchDTXVAD1_GSMAMR_16s,(
const Ipp16s * pSrcWgtLPC1,
const Ipp16s * pSrcWgtLPC2,
const Ipp16s * pSrcSpch,
Ipp16s * pValResultToneFlag,
Ipp16s * pValResultPrevMidPitchLag,
Ipp16s * pValResultVvalue,
Ipp16s * pSrcDstPrevPitchLag,
Ipp16s * pSrcDstPrevWgtSpch,
Ipp16s * pResultMaxHpCorr,
Ipp16s * pDstOpenLoopLag,
Ipp16s * pDstOpenLoopGain,
IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsOpenLoopPitchSearchDTXVAD2_GSMAMR_16s32s
//
// Purpose: Extracts an open-loop pitch lag estimate from the weighted input speech when the VAD 2 scheme
// is enabled
// pSrcWgtLPC1 Pointer to the 44-element vector of weighted LP coefficients
// pSrcWgtLPC2 Pointer to the 44-element vector of weighted LP coefficients
// pSrcSpch Pointer to the 170-sample input speech vector
// pValResultPrevMidPitchLag Pointer to the median filtered pitch lag of the 5 previous voiced
// speech half-frames
// pValResultVvalue Pointer to the adaptive parameter v
// pSrcDstPrevPitchLag Pointer to the five-element vector that contains the pitch lags associated
// with the five most recent voiced speech half-frames
// pSrcDstPrevWgtSpch Pointer to a 143-element vector containing perceptually weighted
// speech from the previous frame
// pResultMaxCorr Pointer to the correlation maximum..
// pResultWgtEnergy Pointer to the pitch delayed energy of the weighted speech signal.
// pDstOpenLoopLag Pointer to a two-element vector of open-loop pitch lags.
// pDstOpenLoopGain Pointer to a 2-element vector containing optimal open-loop pitch gains.
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsOpenLoopPitchSearchDTXVAD2_GSMAMR_16s32s,(
const Ipp16s * pSrcWgtLPC1,
const Ipp16s * pSrcWgtLPC2,
const Ipp16s * pSrcSpch,
Ipp16s * pValResultPrevMidPitchLag,
Ipp16s * pValResultVvalue,
Ipp16s * pSrcDstPrevPitchLag,
Ipp16s * pSrcDstPrevWgtSpch,
Ipp32s * pResultMaxCorr,
Ipp32s * pResultWgtEnergy,
Ipp16s * pDstOpenLoopLag,
Ipp16s * pDstOpenLoopGain,
IppSpchBitRate mode))
#define ippsOpenLoopPitchSearchDTXVAD2_GSMAMR ippsOpenLoopPitchSearchDTXVAD2_GSMAMR_16s32s
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsImpulseResponseTarget_GSMAMR_16s
//
// Purpose: Computes the impulse response and target signal required for the adaptive codebook search.
// pSrcSpch Pointer to the 50-element input speech vector, where elements 0 - 9 are from the
// previous subframe, and elements 10 - 49 are from the current subframe.
// pSrcWgtLPC1 Pointer to an 11-element vector of weighted LP coefficients
// pSrcWgtLPC2 Pointer to an 11-element vector of weighted LP coefficients
// pSrcQLPC Pointer to an 11-element vector of quantized LP coefficients
// pSrcSynFltState Pointer to the 10-element vector that contains the state of the synthesis
// filter
// pSrcWgtFltState Pointer to the 10-element vector that contains the state of the weighting
// filter.
// pDstImpulseResponse Pointer to the 40-element vector that contains the impulse response.
// pDstLpResidual Pointer to the 40-element vector that contains the LP residual.
// pDstAdptTarget Pointer to the 40-element vector that contains the adaptive codebook search
// target signal.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsImpulseResponseTarget_GSMAMR_16s,(
const Ipp16s * pSrcSpch,
const Ipp16s * pSrcWgtLPC1,
const Ipp16s * pSrcWgtLPC2,
const Ipp16s * pSrcQLPC,
const Ipp16s * pSrcSynFltState,
const Ipp16s * pSrcWgtFltState,
Ipp16s * pDstImpulseResponse,
Ipp16s * pDstLpResidual,
Ipp16s * pDstAdptTarget))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookSearch_GSMAMR_16s
//
// Purpose: Performs the adaptive codebook search.
// pSrcAdptTarget Pointer to the 40-element adaptive target signal vector,
// pSrcImpulseResponse Pointer to the 40-element impulse response of the weighted synthesis
// filter.
// pSrcOpenLoopLag Pointer to a two-element vector of open-loop pitch lags.
// pValResultPrevIntPitchLag Pointer to the previous integral pitch lag.
// pSrcDstExcitation Pointer to the 194-element excitation vector.
// pResultFracPitchLag Pointer to the fractional pitch lag obtained during the adaptive codebook
// search.
// pResultAdptIndex Pointer to the coded closed-loop pitch index.
// pDstAdptVector Pointer to the 40-sample adaptive codebook vector.
// subFrame subframe number
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsAdaptiveCodebookSearch_GSMAMR_16s,(
const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcImpulseResponse,
Ipp16s * pSrcOpenLoopLag,
Ipp16s * pValResultPrevIntPitchLag,
Ipp16s * pSrcDstExcitation,
Ipp16s * pResultFracPitchLag,
Ipp16s * pResultAdptIndex,
Ipp16s * pDstAdptVector,
Ipp16s subFrame,
IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookDecode_GSMAMR_16s
//
// Purpose: This function decodes the adaptive codebook parameters transmitted by the encoder, and then
// applies them to interpolate an adaptive codebook vector.
// valAdptIndex Adaptive codebook index.
// pValResultPrevIntPitchLag Pointer to the previous integer pitch lag.
// pValResultLtpLag Pointer to the LTP-Lag value.
// pSrcDstExcitation Pointer to the 194-element excitation vector.
// pResultIntPitchLag Pointer to the 194-element excitation vector.
// pDstAdptVector Pointer to the fractional pitch lag obtained during the adaptive codebook
// subFrame subframe number
// bfi Bad frame indicator. "0" signifies a good frame; any other value signifies a bad frame.
// inBackgroundNoise Flag set when the previous frame is considered to contain background
// noise and only shows minor energy level changes.
// voicedHangover Counter used to monitor the time since a frame was presumably voiced.
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus ,ippsAdaptiveCodebookDecode_GSMAMR_16s,(
Ipp16s valAdptIndex,
Ipp16s * pValResultPrevIntPitchLag,
Ipp16s * pValResultLtpLag,
Ipp16s * pSrcDstExcitation,
Ipp16s * pResultIntPitchLag,
Ipp16s * pDstAdptVector,
Ipp16s subFrame,
Ipp16s bfi,
Ipp16s inBackgroundNoise,
Ipp16s voicedHangover,
IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilter_GSMAMR_16s
//
// Purpose: This function decodes the adaptive codebook parameters transmitted by the encoder, and then
// applies them to interpolate an adaptive codebook vector.
// pSrcQLPC Pointer to the reconstructed LP coefficients, in the length of 44.
// pSrcSpch Pointer to the start position of the input speech signal for current frame.
// pValResultPrevResidual Pointer to the last output of the FIR filter of the formant filter for
// previous subframe.
// pValResultPrevScalingGain Pointer to the scaling factor b of the last signal for the previous
// subframe.
// pSrcDstFormantFIRState Pointer to the state of the FIR part of the formant filter, in the
// length of 10.
// pSrcDstFormantIIRState Pointer to the state of the IIR part of the formant filter, in the length
// of 10.
// pDstFltSpch Pointer to the filtered speech, in the length of 160.
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsPostFilter_GSMAMR_16s,(
const Ipp16s * pSrcQLPC,
const Ipp16s * pSrcSpch,
Ipp16s * pValResultPrevResidual,
Ipp16s * pValResultPrevScalingGain,
Ipp16s * pSrcDstFormantFIRState,
Ipp16s * pSrcDstFormantIIRState,
Ipp16s * pDstFltSpch,
IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsVAD1_GSMAMR_16s
//
// Purpose: Voice Activity Detection (VAD) for AMR (option 1) functions
// pSrcSpch pointer to the input speech signal, in the length of 160
// pSrcDstVad1State pointer to the VAD Option 1 history variables
// pResultVadFlag pointer to the VAD flag of this frame
// maxHpCorr best_corr_hp value of previous frame
// toneFlag tone flag
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsVAD1_GSMAMR_16s,
(const Ipp16s *pSrcSpch,
IppGSMAMRVad1State *pSrcDstVad1State,
Ipp16s *pResultVadFlag,
Ipp16s maxHpCorr,
Ipp16s toneFlag) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsVAD2_GSMAMR_16s
//
// Purpose: Voice Activity Detection (VAD) for AMR (option 2) functions
// pSrcSpch pointer to the input speech signal, in the length of 160
// pSrcDstVad2State pointer to the VAD Option 2 history variables
// pResultVadFlag pointer to the VAD flag of this frame
// ltpFlag LTP_flag value, which is generated by the comparison
// of the long-term prediction to a constant threshold LTP_THLD.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsVAD2_GSMAMR_16s,
(const Ipp16s * pSrcSpch,
IppGSMAMRVad2State *pSrcDstVad2State,
Ipp16s *pResultVadFlag,
Ipp16s ltpFlag) )
/* /////////////////////////////////////////////////////////////////////////////
// G.722.1 related functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDCTFwd_G722, ippsDCTInv_G722
// Purpose: Computes the forward or inverse discrete cosine transform (DCT)
// of a signal.
// Parameters:
// pSrc Pointer to the source vector.
// pDst Pointer to the destination vector.
// len Length of the source and destination vectors either 320
// for G722 by default or 640 for G7221 functions respectively.
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified pointer is NULL.
// IppStsSizeErr Indicates an error when len has an illegal value.
*/
IPPAPI( IppStatus, ippsDCTFwd_G722_16s, (const Ipp16s *pSrc, Ipp16s *pDst))
IPPAPI( IppStatus, ippsDCTFwd_G7221_16s, (const Ipp16s *pSrc, Ipp16s *pDst, int len))
IPPAPI( IppStatus, ippsDCTInv_G722_16s, (const Ipp16s *pSrc, Ipp16s *pDst))
IPPAPI( IppStatus, ippsDCTInv_G7221_16s, (const Ipp16s *pSrcMLT, Ipp16s *pDstSmpl, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecomposeMLTToDCT_G722
// Purpose: Decompose MLT transform input signal to form of the DCT transform
// input signal.
// Parameters:
// pSrcSpch Pointer to the source speech vector .
// pSrcSpchOld Pointer to the source/destination vector of
// the previous speech frame.
// pDstSpchDecomposed Pointer to the destination decomposed speech vector.
// len Length of the source and destination vectors either 320
// for G722 by default or 640 for G7221 functions respectively.
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified pointer is NULL.
// IppStsSizeErr Indicates an error when len has an illegal value.
*/
IPPAPI( IppStatus, ippsDecomposeMLTToDCT_G722_16s, (const Ipp16s *pSrcSpch,
Ipp16s *pSrcDstSpchOld, Ipp16s *pDstSpchDecomposed))
IPPAPI( IppStatus, ippsDecomposeMLTToDCT_G7221_16s, (const Ipp16s *pSrcSpch,
Ipp16s *pSrcDstSpchOld, Ipp16s *pDstSpchDecomposed, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecomposeDCTToMLT_G722_16s
// Purpose: Decompose IDCT output signal to form of the MLT transform output signal.
// Parameters:
// pSrcSpchDecomposed Pointer to the source windowed speech vector[len].
// pSrcSpchDecomposedOld Pointer to the source/destination
// windowed speech vector[len/2] of previous frame.
// pDstSpch Pointer to the destination speech vector[len].
// len Length of destination vectors either 320 for G722
// by default or 640 for G7221 functions respectively.
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified pointer is NULL.
// IppStsSizeErr Indicates an error when len has an illegal value.
*/
IPPAPI( IppStatus, ippsDecomposeDCTToMLT_G722_16s, (const Ipp16s *pSrcSpchDecomposed,
Ipp16s *pSrcDstSpchDecomposedOld, Ipp16s *pDstSpch))
IPPAPI( IppStatus, ippsDecomposeDCTToMLT_G7221_16s, (const Ipp16s *pSrcSpchDecomposed,
Ipp16s *pSrcDstSpchDecomposedOld, Ipp16s *pDstSpch, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHuffmanEncode_G722
// Purpose: Performs Huffman encoding of the quantized amplitude envelope indexes.
// Parameters:
// category The category of MLT region in range of [0-7]
// qntAmpEnvIndex The quantized amplitude envelope index in range of [0-63]
// pSrcMLTCoeffs Pointer to the source vector[20] of raw MLT coefficients.
// pDstCode Pointer to the output Huffman code.
// pCodeLength Pointer to output Huffman code length in bit.
// Returns:
// ippStsNoErr Indicates no error.
// IppStsNullPtrErr Indicates an error when the pSrcMLTCoeffs or pDstCode
// or pCodeLength pointer is null
// IppStsScaleRangeErr Indicates an error when category or qntAmpEnvIndex is out of
// proper range.
*/
IPPAPI( IppStatus, ippsHuffmanEncode_G722_16s32u, (int category, int qntAmpEnvIndex,
const Ipp16s *pSrcMLTCoeffs, Ipp32u *pDstCode, int *pCodeLength))
/* /////////////////////////////////////////////////////////////////////////////
// G.722.1 end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// G.726 related functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct _EncoderState_G726_16s IppsEncoderState_G726_16s;
typedef struct _DecoderState_G726_16s IppsDecoderState_G726_16s;
#endif
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncodeGetStateSize_G726
// Purpose: Query of G726 encoder memory size
// Parameters:
// pEncSize Pointer to the output value of the G726 encoder memory size in bytes
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsEncodeGetStateSize_G726_16s8u,(unsigned int* pEncSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncodeInit_G726
// Purpose: Initializes the memory for the ADPCM encode
// Parameters:
// pEncMem Pointer to the input memory buffer of appropriate size applicable to
// store a state of the encoder
// rate Encode bit rate of the G.726 encoder: IPP_SPCHBR_16000,
// IPP_SPCHBR_24000, IPP_SPCHBR_32000, IPP_SPCHBR_40000.
// Returns:
// ippStsBadArgErr Indicates an error when the rate is not equal to one of the
// allowable encoding bit rates: IPP_SPCHBR_16000, IPP_SPCHBR_24000 or
// IPP_SPCHBR_32000, IPP_SPCHBR_40000.
// IppStsNullPtrErr Indicates an error when the memory pointer is null
*/
IPPAPI(IppStatus, ippsEncodeInit_G726_16s8u,
(IppsEncoderState_G726_16s* pEncMem, IppSpchBitRate rate))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncode_G726
// Purpose: ADPCM encoding of input speech signal
// Parameters:
// pEncMem Pointer to the encoder state memory
// pSrc Pointer to the uniform PCM input speech vector.
// pDst Pointer to the ADPCM bit-stream output vector.
// len The length of input/output vectors.
// Returns:
// ippStsNoErr, if no errors
// ippStsBadArgErr Indicates an error when the len is less or equal to 0.
// IppStsNullPtrErr Indicates an error when the pEncMem , pSrc, pDst pointer is null
*/
IPPAPI(IppStatus, ippsEncode_G726_16s8u,
(IppsEncoderState_G726_16s* pEncMem, const Ipp16s *pSrc, Ipp8u *pDst, unsigned int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncodeGetStateSize_G726
// Purpose: Query of G726 decoder memory size
// Parameters:
// pDecSize Pointer to the output value of the G726 decoder memory size in bytes
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsDecodeGetStateSize_G726_8u16s,(unsigned int* pDecSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncodeInit_G726
// Purpose: Initializes the memory for the ADPCM encode
// Parameters:
// pDecMem Pointer to the input memory buffer of appropriate size applicable to
// store a state of the decoder
// rate input bit rate of the G.726 decoder: IPP_SPCHBR_16000,
// IPP_SPCHBR_24000, IPP_SPCHBR_32000, IPP_SPCHBR_40000.
// law Output speech PCM law : IPP_PCM_MULAW, IPP_PCM_ALAW, IPP_PCM_LINEAR
// Returns:
// ippStsBadArgErr Indicates an error when the rate is not equal to one of the
// allowable decoding bit rates: IPP_SPCHBR_16000, IPP_SPCHBR_24000 or
// IPP_SPCHBR_32000,
// IPP_SPCHBR_40000 or the law is not equal to one othe allowable output PCM:
// IPP_PCM_MULAW, IPP_PCM_ALAW, IPP_PCM_LINEAR.
// IppStsNullPtrErr Indicates an error when the obj pointer is null
*/
IPPAPI(IppStatus, ippsDecodeInit_G726_8u16s,
(IppsDecoderState_G726_16s* pDecMem, IppSpchBitRate rate, IppPCMLaw law))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecode_G726
// Purpose: Initializes the memory for the ADPCM encode
// Parameters:
// pDecMem Pointer to the decoder state memory
// pSrc Pointer to the input ADPCM code vector contains two, three,
// four or five bits of the ADPCM codes per byte respectively for
// 16, 24, 32 or 40 Kbit/s bit rates.
// pDst Pointer to the 16bit linear PCM speech output vector.
// len The length of input/output vectors.
// Returns:
// ippStsNoErr, if no errors
// ippStsBadArgErr Indicates an error when the len is less or equal to 0.
// IppStsNullPtrErr Indicates an error when the pDecMem , pSrc, pDst pointer is null
*/
IPPAPI(IppStatus, ippsDecode_G726_8u16s,
(IppsDecoderState_G726_16s* pDecMem, const Ipp8u *pSrc, Ipp16s *pDst, unsigned int len))
/* /////////////////////////////////////////////////////////////////////////////
// G.726 end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// G.728 related functions
///////////////////////////////////////////////////////////////////////////// */
/*
// Name: ippsIIR16s_G728
// Purpose: IIR filter
// 1+B(1/z)/1+A(1/z)
// pCoeffs pointer to the input filter coefficients B[11], A[11] in Q14
// pSrcQntSpeech pointer to the input quantized speech vector
// pDstWgtSpeech pointer to the output perceptually weighted speech vector
// pMem pointer to the filter memory
*/
#if !defined( _OWN_BLDPCS )
typedef struct _IIRState_G728_16s IppsIIRState_G728_16s;
#endif
IPPAPI(IppStatus, ippsIIR16sGetStateSize_G728_16s, (int *pSize))
IPPAPI(IppStatus, ippsIIR16sInit_G728_16s, (IppsIIRState_G728_16s *pMem ))
IPPAPI(IppStatus, ippsIIR16s_G728_16s, (const Ipp16s *pCoeffs, const Ipp16s *pSrcQntSpeech,
Ipp16s *pDstWgtSpeech, int len, IppsIIRState_G728_16s *pMem ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippSynthesisFilter_G728
// Purpose: Synthesis filter of size LPC (50)
// 1/1+A(1/z)
// pCoeffs pointer to the input LPC filter coefficients vector[51]
// pSrcDstExc pointer to the input/output gain-scaled excitation vector[5] (ET)
// excSfs input scale of the previous gain-scaled excitation vector (NLSET)
// pDstSpeech pointer to the output quantized speech vector[5] (ST)
// pSpeechSfs output scale of the quantized speech vector (NLSST)
// pMem pointer to the filter memory
*/
#if !defined( _OWN_BLDPCS )
typedef struct _SynthesisFilterState_G728_16s IppsSynthesisFilterState_G728_16s;
#endif
IPPAPI(IppStatus, ippsSynthesisFilterGetStateSize_G728_16s,(int* pSize))
IPPAPI(IppStatus, ippsSynthesisFilterInit_G728_16s,(IppsSynthesisFilterState_G728_16s *pMem))
IPPAPI(IppStatus, ippsSyntesisFilterZeroInput_G728_16s,(const Ipp16s* pCoeffs,
Ipp16s *pSrcDstExc, Ipp16s excSfs,Ipp16s *pDstSpeech, Ipp16s *pSpeechSfs,
IppsSynthesisFilterState_G728_16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCombinedFilter_G728
// Purpose: Combined filter
// Synthesis filter of size LPC (50) + Perceptual weighted filter (IIR)
// 1/1+A(1/z) * 1+B(1/z)/1+A(1/z)
// pSyntCoeffs pointer to the input LPC coefficient vector[51]: 1, a0,...,a50
// pWgtCoeffs pointer to the input WGT filter coefficients B[11] 1,b0,...,b10,
and A[11] 1,a0,...,a10 in Q14
// pDstWgtZIR pointer to the output synthesized speech vector
// pSrcDstExc pointer to the input/output gain-scaled excitation vector[5] (ET)
// excSfs input scale of the previous gain-scaled excitation vector (NLSET)
// pDstSpeech pointer to the output quantized speech vector[5] (ST)
// pSpeechSfs output scale of the quantized speech vector (NLSST)
// pMem pointer to the filter memory
*/
#if !defined( _OWN_BLDPCS )
typedef struct _CombinedFilterState_G728_16s IppsCombinedFilterState_G728_16s;
#endif
IPPAPI(IppStatus, ippsCombinedFilterGetStateSize_G728_16s,(int* pSize))
IPPAPI(IppStatus, ippsCombinedFilterInit_G728_16s,(IppsCombinedFilterState_G728_16s* pMem))
IPPAPI(IppStatus, ippsCombinedFilterZeroInput_G728_16s,(const Ipp16s* pSyntCoeff,
const Ipp16s* pWgtCoeff, Ipp16s* pDstWgtZIR, IppsCombinedFilterState_G728_16s* pMem))
IPPAPI(IppStatus, ippsCombinedFilterZeroState_G728_16s,(const Ipp16s* pSyntCoeff,
const Ipp16s* pWgtCoeff, Ipp16s* pSrcDstExc, Ipp16s excSfs,
Ipp16s* pDstSpeech, Ipp16s* pSpeechSfs, IppsCombinedFilterState_G728_16s* pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilter_G728
// Purpose: Post filter
// gl*(1+glb*1/z^kp)* 1-B(1/z)/1-A(1/z) * (1+kp*1/z)
// gl LTP scaling factor
// glb LTP product term
// kp LTP lag, pitch period of current frame
// tiltz STP tilt-compensation coefficient
// pCoeffs pointer to the input LPC filter coefficients B(10), A(10)
// pSrc pointer to the input quantized speech vector SST [-kp,IDIM-1]
// pDst pointer to the output postfiltered speech vector
// pSTPmem pointer to the filter memory (61 short integers)
*/
#if !defined( _OWN_BLDPCS )
typedef struct _PostFilterState_G728_16s IppsPostFilterState_G728_16s;
#endif
IPPAPI(IppStatus, ippsPostFilterGetStateSize_G728_16s,(int *pSize))
IPPAPI(IppStatus, ippsPostFilterInit_G728_16s,(IppsPostFilterState_G728_16s *pMem))
IPPAPI(IppStatus, ippsPostFilter_G728_16s,(Ipp16s gl, Ipp16s glb, Ipp16s kp, Ipp16s tiltz,
const Ipp16s *pCoeffs, const Ipp16s *pSrc, Ipp16s *pDst,
IppsPostFilterState_G728_16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsWinHybrid_G728
// Purpose: Hybrid window auto-correlation for backward-adaptive analysis
// in LD-CELP window:
// s(M-N),s(M-N+1),...,s(M-1),s(M),s(M+1),...,s(M+L-1)
// M LPC order for backward adaptation
// L number of signal samples in backward adaptation
// N number of non-recursive samples in the hybrid window
// DIM block size, shall be defined for block scaled operation by
// the function _ippsWinHybridBlock_G728_16s,
// where pSrcSfs[i] is the scale factor of pSrc[i*DIM],...,pSrc[i*DIM+DIM-1]
// If 0, then default scale factor 14 is always used.
// pSrc input signal for backward-adaptive analysis
//
// ippsWinHybridGetStateSize_G728_16s: return the size of HWM memory
// ippsWinHybridInit_G728_16s: initialized the HWM memory given
// ippsWinHybridBlock_G728_16s : block operation
// ippsWinHybrid_G728_16s : non-block operation
*/
#if !defined( _OWN_BLDPCS )
typedef struct _WinHybridState_G728_16s IppsWinHybridState_G728_16s;
#endif
IPPAPI(IppStatus, ippsWinHybridGetStateSize_G728_16s,(int M, int L, int N, int DIM, int *pMemSize))
IPPAPI(IppStatus, ippsWinHybridInit_G728_16s,(const Ipp16s *pWinTab,int M, int L, int N,
int DIM, Ipp16s a2L, IppsWinHybridState_G728_16s *pMem))
IPPAPI(IppStatus, ippsWinHybridBlock_G728_16s,(Ipp16s bfi, const Ipp16s *pSrc, const Ipp16s *pSrcSfs, Ipp16s *pDst,
IppsWinHybridState_G728_16s *pMem))
IPPAPI(IppStatus, ippsWinHybrid_G728_16s,(Ipp16s bfi, const Ipp16s *pSrc, Ipp16s *pDst,
IppsWinHybridState_G728_16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLevinsonDurbin_G728
// Purpose: Calculates LPC by Levinson-Durbin recursion
// pSrcAutoCorr pointer to the autocorrelation vector
// numSrcLPC number of precalculated LPC
// order LP order
// pDstLPC pointer to the LPC output vector
// pSrcDstLPC pointer to the input/output LPC vector
// pDstRC1 pointer to the output first RC
// pDstResidualEnergy pointer to output residual energy
// pDstScaleFactor pointer to the output scale factor of LPC
// pSrcDstScaleFactor pointer to the input/output scale factor of LPC
*/
IPPAPI(IppStatus, ippsLevinsonDurbin_G728_16s_Sfs,(const Ipp16s *pSrcAutoCorr,
int order,
Ipp16s *pDstLPC,
Ipp16s *pDstRC1,
Ipp16s *pDstResidualEnergy,
Ipp16s *pDstScaleFactor))
IPPAPI(IppStatus, ippsLevinsonDurbin_G728_16s_ISfs,(const Ipp16s *pSrcAutoCorr,
int numSrcLPC,
int order,
Ipp16s *pSrcDstLPC,
Ipp16s *pSrcDstResidualEnergy,
Ipp16s *pSrcDstScaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCodebookSearch_G728
// Purpose: Search for the best codebook vector
// pSrcCorr pointer to the input correlation vector
// pSrcEnergy pointer to the input energy of convolved shape codevector
// pDstShapeIdx pointer to the output best 7-bit shape codebook index
// pDstGainIdx pointer to the output best 3-bit gain codebook index
// rate input coding bit rate :
// IPP_SPCHBR_16000, IPP_SPCHBR_12800 or IPP_SPCHBR_9600
*/
IPPAPI(IppStatus, ippsCodebookSearch_G728_16s,(
const Ipp16s* pSrcCorr, const Ipp16s* pSrcEnergy,
int* pDstShapeIdx, int* pDstGainIdx, Ipp16s* pDstCodebookIdx, IppSpchBitRate rate))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsImpulseResponseEnergy_G728
// Purpose: Shape codevector convolution and energy calculation
// pSrcImpResp - pointer to the input impulse response vector of F(z)W(z)
// pDstEnergy - pointer to the output energy of convolved shape codevector Y2[1,NCWD]
*/
IPPAPI(IppStatus, ippsImpulseResponseEnergy_G728_16s,(const Ipp16s *pSrcImpResp, Ipp16s *pDstEnergy))
/* Postfilter adapter block */
#if !defined( _OWN_BLDPCS )
typedef struct _PostFilterAdapterState_G728 IppsPostFilterAdapterState_G728;
#endif
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilterAdapterGetStateSize_G728
// Purpose: return the size of postfilter adapter memory.
*/
IPPAPI(IppStatus, ippsPostFilterAdapterGetStateSize_G728, (int *pSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilterAdapterStateInit_G728
// Purpose: initializes the memory for postfilter adapter.
*/
IPPAPI(IppStatus, ippsPostFilterAdapterStateInit_G728, (IppsPostFilterAdapterState_G728 *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLPCInverseFilter_G728_16s
//
// Purpose: compute the LPC prediction residual for the current decoded speech vector. (block 81)
// Parameters:
// pSrcSpeech pointer to quantized speech buffer. (sst)
// pCoeffs pointer to 10th-order LPC filter coefficients. (apf)
// pDstResidual pointer to LPC prediction residual memory. (d)
// pMem pointer to postfilter adapter memory. (LPC inverse filter memory - "stlpci")
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr At least one of the specified pointers is NULL
// Notes:
*/
IPPAPI(IppStatus, ippsLPCInverseFilter_G728_16s, (const Ipp16s* pSrcSpeech, const Ipp16s* pCoeffs,
Ipp16s* pDstResidual, IppsPostFilterAdapterState_G728* pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPitchPeriodExtraction_G728_16s
//
// Purpose: extract the pitch period from the LPC prediction residual. (block 82)
// Parameters:
// pSrcResidual pointer to LPC prediction residual memory. (d)
// pPitchPeriod pointer to the pitch period of the frame. (kp1)
// pMem pointer to postfilter adapter memory. (lpfiir, lpfiir, dec)
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr At least one of the specified pointers is NULL
// Notes:
*/
IPPAPI(IppStatus, ippsPitchPeriodExtraction_G728_16s, (const Ipp16s* pSrcResidual,
int* pPitchPeriod, IppsPostFilterAdapterState_G728* pMem))
/* /////////////////////////////////////////////////////////////////////////////
// G.728 end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// GSMFR related functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRPEQuantDecode_GSMFR_16s
// Purpose: APCM inverse quantization: decoding the RPE sequence of coded xMc
// pSrc pointer to the input RPE pulses vector[13] (xMc)
// pDst pointer to the output reconstructed long-term residual vector[13] (xMp)
// ampl block amplitude (xmaxc)
// amplSfs block amplitude scale factor
*/
IPPAPI(IppStatus, ippsRPEQuantDecode_GSMFR_16s,
(const Ipp16s *pSrc, Ipp16s ampl, Ipp16s amplSfs, Ipp16s *pDst))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDeemphasize_GSMFR_16s_I
// Purpose: De-emphasis filtering (GSM 06.10 5.3.5)
// pSrcDst pointer to the input ST-synthesized signal (sr)
// and output post-processed speech (sr0)
// pMem pointer to the filter memory element
// len length of input/output vector
*/
IPPAPI(IppStatus, ippsDeemphasize_GSMFR_16s_I,(Ipp16s *pSrcDst,int len,Ipp16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsShortTermSynthesisFilter_GSMFR_16s
// Purpose: Short-term synthesis filtering (GSM 06.10 5.3.2)
// 1/A(z)
// pRC pointer to the input reflection coefficients vector[8]
// pSrc pointer to the input reconstructed short term residual vector[len]
// pDstSpch pointer to the output speech vector[len]
// len length of input residual and output speech vectors
// pMem pointer to the filter memory vector[9]
*/
IPPAPI(IppStatus, ippsShortTermSynthesisFilter_GSMFR_16s,
(const Ipp16s *pRC, const Ipp16s *pSrcResidual, Ipp16s *pDstSpch, int len, Ipp16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsShortTermAnalysisFilter_GSMFR_16s_I
// Purpose: Short-term analysis filtering (GSM 06.10 5.2.10)
// 1/A(z)
// pRC pointer to the input reflection coefficients vector[8]
// pSrcDstSpch pointer to the input preprocessed signal and output
// short term residual vector[len]
// len length of input residual and output speech vectors
// pMem pointer to the filter memory vector[9]
*/
IPPAPI(IppStatus, ippsShortTermAnalysisFilter_GSMFR_16s_I,
(const Ipp16s *pRC, Ipp16s *pSrcDstSpch, int len, Ipp16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilter_GSMFR
// Purpose: Offset compensation of the input signal, GSM 06.10 5.2.2
// Parameters:
// pSrc pointer to the input speech vector
// pDst pointer to the output filtered vector
// len length of input and output vectors
// pMem pointer to the filter memory vector[2]
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsHighPassFilter_GSMFR_16s,
(const Ipp16s *pSrc, Ipp16s *pDst,int len,int *pMem))
/*/////////////////////////////////////////////////////////////////////////////
// Name: ippsSchur_GSMFR
// Purpose: Calculates reflection coefficients using Schur algorithm. GSM 06.10 5.2.5.
//
// Arguments:
// pSrc - Pointer to the input autocorrelations vector
// pDst - Pointer to the output reflection coefficients vector
// dstLen - vector destination length
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsSchur_GSMFR_32s16s,(const Ipp32s *pSrc,Ipp16s *pDst,int dstLen))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsWeightingFilter_GSMFR
// Purpose: weighting filtering. GSM 06.10 5.2.13
// Arguments:
// pSrc - pointer to the source vector
// pDst - pointer to the destination vector
// dstLen - source/destination length
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsWeightingFilter_GSMFR_16s,(const Ipp16s *pSrc, Ipp16s *pDst,int dstLen))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPreemphasize_GSMFR
// Purpose: preemphasize offset compensated signal. GSM 06.10 5.2.3
// Arguments:
// pSrc - pointer to the source vector
// pDst - pointer to the destination vector
// pMem - pointer to the filter memory value
// len - source/destination length
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsPreemphasize_GSMFR_16s,
(const Ipp16s *pSrc, Ipp16s *pDst, int len, Ipp16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// GSMFR end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// AMRWB related functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsResidualFilter_AMRWB_16s_Sfs
// Purpose: Compute the LPC residual by filtering the input speech through A(z).
// rounding to nearest:
// const1 = 1<<(scaleFactor-1)
// (a*b+const1)>>scaleFactor;
// Parameters:
// pSrcLpc pointer to the input LPC
// valLPCOrder length of the LPC vector
// pSrcSpeech pointer to the input vector[-valLPCOrder,..,-1,0,...,,len-1]
// pDstResidualSignal pointer to the output vector of length[len]
// len length of the vectors
// scaleFactor scale factor value
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsResidualFilter_AMRWB_16s_Sfs,(
const Ipp16s *pSrcLpc,
Ipp16s valLPCOrder,
const Ipp16s *pSrcSpeech,
Ipp16s *pDstResidualSignal,
Ipp32s len,
Ipp32s scaleFactor
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsResidualFilter_Low_16s_Sfs
// Purpose: Compute the LPC residual by filtering the input speech through A(z).
// rounding to nearest:
// const1 = 1<<(scaleFactor-1)
// (a*b+const1)>>scaleFactor;
// Parameters:
// pSrcLpc pointer to the input LPC
// valLPCOrder length of the LPC vector
// pSrcSpeech pointer to the input vector[-valLPCOrder,..,-1,0,...,,len-1]
// pDstResidualSignal pointer to the output vector of length[len]
// len length of the vectors
// scaleFactor scale factor value
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsResidualFilter_Low_16s_Sfs,(
const Ipp16s *pSrcLpc,
Ipp16s valLPCOrder,
const Ipp16s *pSrcSpeech,
Ipp16s *pDstResidualSignal,
Ipp32s len,
Ipp32s scaleFactor
))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsLPCToISP_AMRWB_16s
// Purpose: LP to ISP coefficients conversion
// Parameters:
// pSrcLpc pointer to the input predictor coefficients
// pDstIsp pointer to the output immittance spectral pairs
// pSrcPrevIsp pointer to the input previous immittance spectral pairs.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsLPCToISP_AMRWB_16s,(
const Ipp16s *pSrcLpc,
Ipp16s *pDstIsp,
const Ipp16s *pSrcPrevIsp
))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsISPToLPC_AMRWB_16s
// Purpose: ISP to LP coefficients conversion
// Parameters:
// pSrcIsp pointer to the input immittance spectral pairs
// pDstLpc pointer to the output predictor coefficients
// len length of the destination vector.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsISPToLPC_AMRWB_16s,(
const Ipp16s *pSrcIsp,
Ipp16s *pDstLpc,
Ipp32s len
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISPToISF_Norm_AMRWB_16s
// Purpose:
// pDstIsf[i] = arccos(pSrcIsp[i]); i=0,...,lenLpc
// result is 15 bit scaled in range [0:0.5]
// Parameters:
// pSrcIsp pointer to the ISP input vector of values 15 bit scaled in range [-1:1]
// pDstIsf pointer to the ISF output vector
// len ISP order
// Returns: ippStsNoErr, if no errors
*/
IPPAPI( IppStatus, ippsISPToISF_Norm_AMRWB_16s,(
const Ipp16s *pSrcIsp,
Ipp16s *pDstIsf,
Ipp32s len
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFToISP_AMRWB_16s
// Purpose: ISF interpolation and conversion to LPC
// Parameters:
// pSrcIsf pointer to the ISF input vector of values 15 bit scaled in range [0:0.5]
// pDstIsp pointer to the LPC output vector of values 15 bit scaled in range [-1:1]
// len ISP order
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI( IppStatus, ippsISFToISP_AMRWB_16s,(
const Ipp16s *pSrcIsf,
Ipp16s *pDstIsp,
Ipp32s len
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncDTXBuffer_AMRWB_16s
//
// Purpose: Function buffer the ISP coefficients and previous log energy coefficients.
// Parameters:
// pSrcSpch - Pointer to the input speech signal, in the length of 320, in Q15.0.
// pSrcLsp - Pointer to the ISP for this frame, in the length of 16, in Q0.15.
// pUpdateIndex - Pointer to the previous memory update index. It is a value
// circularly increased between 0 and 7.
// pSrcDstLspBuffer - Pointer to the ISP coefficients of eight previous frames, in the
// length of 128, in Q0.15.
// pSrcDstLogEnergyBuffer - Pointer to the logarithm energy coefficients of eight previous
// frames,in the length of 8,in Q5.10.
// mode - coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsEncDTXBuffer_AMRWB_16s,(const Ipp16s * pSrcSpch,
const Ipp16s *pSrcIsp, Ipp16s *pUpdateIndex, Ipp16s *pSrcDstIspBuffer,
Ipp16s *pSrcDstLogEnergyBuffer, IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecDTXBuffer_AMRWB_16s
//
// Purpose: Function buffer the ISF coefficients and previous log energy coefficients.
// Parameters:
// pSrcSpch - Pointer to the input speech signal, in the length of 320, in Q15.0.
// pSrcIsf - Pointer to the ISF for this frame, in the length of 16, in Q0.15.
// pUpdateIndex - Pointer to the previous memory update index. It is a value
// circularly increased between 0 and 7.
// pSrcDstIsfBuffer - Pointer to the ISF coefficients of eight previous frames, in the
// length of 128, in Q0.15.
// pSrcDstLogEnergyBuffer - Pointer to the logarithm energy coefficients of eight previous
// frames,inthelength of 8,in Q5.10.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsDecDTXBuffer_AMRWB_16s,(const Ipp16s *pSrcSpch,
const Ipp16s *pSrcIsf, Ipp16s *pUpdateIndex,
Ipp16s *pSrcDstIsfBuffer, Ipp16s *pSrcDstLogEnergyBuffer))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsOpenLoopPitchSearch_AMRWB_16s
//
// Purpose: Extracts an open-loop pitch lag estimate from the weighted input speech
// Parameters:
// pSrcWgtSpch Pointer to a 320-element vector containing
// perceptually weighted speech.
// pSrcFltWgtSpch Pointer to a 320-element vector containing filtered
// perceptually weighted speech.
// pPrevMidPitchLag Pointer to the median filtered pitch lag
// of the 5 previous voiced
// speech half-frames
// pAdaptiveParam Pointer to the adaptive parameter.
// pDstOpenLoopLag Pointer to the open-loop pitch lag.
// pToneFlag Pointer to the tone flag for the VAD module.
// pDstOpenLoopGain Pointer to the optimal open-loop pitch gain.
// pSrcDstPrevPitchLag Pointer to the five-element vector that contains
// the pitch lags associated
// with the five most recent voiced speech half-frames
// pSrcDstLagSwitcher Switches lag weighting on and off
// len Length of the frame.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsOpenLoopPitchSearch_AMRWB_16s,(const Ipp16s *pSrcWgtSpch,
const Ipp16s * pSrcFltWgtSpch, Ipp16s * pPrevMidPitchLag,
Ipp16s * pAdaptiveParam, Ipp16s * pDstOpenLoopLag,
Ipp16s * pToneFlag, Ipp16s * pDstOpenLoopGain,
Ipp16s * pSrcDstPrevPitchLag, Ipp16s * pSrcDstLagSwitcher, int len ))
#if !defined( _OWN_BLDPCS )
typedef struct _HighPassFilterState_AMRWB_16s IppsHighPassFilterState_AMRWB_16s;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilterGetSize_AMRWB_16s
// Purpose: Query of AMRWB HP filter state memory size
// Parameters:
// pDstSize Pointer to the output value of the memory size needed for filtering
// order Order of filter/ Currently only 2 or 3 is supported
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsHighPassFilterGetSize_AMRWB_16s,(int order, int *pDstSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilterInit_AMRWB_16s
// Purpose: Initialization of the memory allocated for AMR WB high pass filter
// Parameters:
// pFilterCoeffA Pointer to a 4-element vector containing
// IIR part of the coefficiensts of the filter
// pFilterCoeffB Pointer to a 4-element vector containing
// FIR part of the coefficiensts of the filter
// pState pointer to the memory supplied for filtering
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsHighPassFilterInit_AMRWB_16s,
(Ipp16s *pFilterCoeffA, Ipp16s *pFilterCoeffB, int order,
IppsHighPassFilterState_AMRWB_16s *pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilter_AMRWB
// Purpose: High-pass filtering
// Parameters:
// pSrc pointer to the input vector[len]
// pDst pointer to the vector [len].
// pSrcDst pointer to the input/output vector [len].
// len length of the input and output vectors.
// pState pointer to the memory supplied for filtering
// valBounds if valBounds = 0 then pSrc[-1] and pSrc[len] are equal to zero
// otherwise they must be given.
// scaleFactor Scale factor
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsHighPassFilter_AMRWB_16s_Sfs,(
const Ipp16s *pSrc, Ipp16s *pDst, int len,
IppsHighPassFilterState_AMRWB_16s *pState, int scaleFactor))
IPPAPI(IppStatus, ippsHighPassFilter_AMRWB_16s_ISfs,(
Ipp16s *pSrcDst, int len,
IppsHighPassFilterState_AMRWB_16s *pState, int scaleFactor))
IPPAPI(IppStatus, ippsHighPassFilter_Direct_AMRWB_16s,(
const Ipp16s *pSrcCoeff, const Ipp16s *pSrc, Ipp16s *pDst, int len, int valBounds ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilterGetDlyLine_AMRWB_16s
// Purpose: Get the delay line of high-pass filter.
// Parameters:
// pState Pointer to the memory supplied for filtering.
// pDlyLine Pointer to the vector of size [6 or 9] containing the filter memory.
// order The order of high-pass filter; orders of 2 and 3 is currently supported.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsHighPassFilterGetDlyLine_AMRWB_16s,
(const IppsHighPassFilterState_AMRWB_16s* pState, Ipp16s* pDlyLine, Ipp32s order))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilterSetDlyLine_AMRWB_16s
// Purpose: Set the delay line of high-pass filter.
// Parameters:
// pDlyLine Pointer to the vector of size [6 or 9] containing the filter memory.
// pState Pointer to the memory supplied for filtering.
// order The order of high-pass filter; orders of 2 and 3 is currently supported.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsHighPassFilterSetDlyLine_AMRWB_16s,
(const Ipp16s* pDlyLine, IppsHighPassFilterState_AMRWB_16s* pState, Ipp32s order))
/* /////////////////////////////////////////////////////////////////////////////
// AMRWB Voice Activity Detector functions
// /////////////////////////////////////////////////////////////////////////////
*/
#if !defined( _OWN_BLDPCS )
typedef struct _VADState_AMRWB_16s IppsVADState_AMRWB_16s;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsVADGetSize_AMRWB_16s
// Purpose: AMRWB VADetector size -
// computes the size,in bytes,
// of the state variable structure IppsVADState_AMRWB_16s.
// Parameters:
// pState pointer to the VAD history variables
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsVADGetSize_AMRWB_16s,(int *pDstSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsVADGetSize_AMRWB_16s
// Purpose: Initialize AMRWB VADetector -
// of the state variable structure IppsVADState_AMRWB_16s.
// Parameters:
// pState pointer to the VAD history variables
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsVADInit_AMRWB_16s,(
IppsVADState_AMRWB_16s *pState
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsVADGetEnergyLevel_AMRWB_16s
// Purpose: return energy level vector
// Parameters:
// pState pointer to the VAD history variables
// pEnergyLevel pointer to the destination vector of enrgy level [12]
// Returns: IppStatus
// ippStsNoErr if no error
// ippStsNullPtrErr if at least one of the poiners is null.
*/
IPPAPI (IppStatus, ippsVADGetEnergyLevel_AMRWB_16s,
(const IppsVADState_AMRWB_16s* pState, Ipp16s* pEnergyLevel))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsVAD_AMRWB_16s
//
// Purpose: AMRWB VADetector -
// detect type of frame - active (voice) or inactive (unvoiced)
// Parameters:
// pSrcSpch pointer to the input speech signal, in the length of 320
// pState pointer to the VAD history variables
// pVadFlag pointer to the VAD type detected (1 - voice)
// pToneFlag pointer to tone detected
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsVAD_AMRWB_16s,(const Ipp16s *pSrcSpch,
IppsVADState_AMRWB_16s *pState,
Ipp16s *pToneFlag,
Ipp16s *pVadFlag))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAlgebraicCodebookSearch_AMRWB_16s
//
// Purpose: Fixed (algebraic) codebook search functions
// Parameters:
// pSrcFixedTarget target vector
// pSrcLtpResidual long term prediction residual
// pSrcDstImpulseResponse impulse response of weighted synthesis
// filter h[-L_subfr..-1] must be set to zero
// pDstFixedVector innovative codebook
// pDstFltFixedVector filtered fixed codebook excitation
// pDstIndex Indexes of the pulses
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAlgebraicCodebookSearch_AMRWB_16s,(
const Ipp16s *pSrcFixedTarget,
const Ipp16s *pSrcLtpResidual,
Ipp16s *pSrcDstImpulseResponse,
Ipp16s *pDstFixedVector,
Ipp16s *pDstFltFixedVector,
IppSpchBitRate mode,
Ipp16s *pDstIndex
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAlgebraicCodebookDecode_AMRWB_16s
//
// Purpose: This function decodes the fixed (algebraic) codebook parameters transmitted by the encoder.
// Parameters:
// pSrcIdxs Algebraic codebook indexes.
// pDstFixedCode Pointer to the algebraic codevector, in the length of 64
// mode coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAlgebraicCodebookDecode_AMRWB_16s,(
const Ipp16s *pSrcIdxs,
Ipp16s *pDstFixedCode,
IppSpchBitRate mode
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsInterpolateC_NR_16s
// Purpose: interpolation of two vector
// dst = (src1*va1*2^scaleFactor1 + src2*val2*2^scaleFactor2)*2^-16
// Parameters:
// pSrc1 pointer to the input vector1
// val1 interpolation coeff. of first vector
// val1ScaleFactor val1 scaling factor
// pSrc2 pointer to the input vector2
// val2 interpolation coeff. of second vector
// val2scaleFactor val2 scaling factor
// pDst pointer to the interpolated output vector
// len length of the vectors
/ Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsInterpolateC_NR_16s,
(const Ipp16s *pSrc1, Ipp16s val1, int val1ScaleFactor, const Ipp16s *pSrc2,
Ipp16s val2, int val2ScaleFactor, Ipp16s *pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPreemphasize_AMRWB_16s_ISfs
// Purpose: Preemphasis filter
// H(z) = 1 - gamma z^-1
// Parameters:
// pSrcDst pointer to the input/output vector
// gamma filter coeeficient
// ScaleFactor scale factor for the result
// len length of the input/output vector
// pMem pointer to the filter memory of length 1
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsPreemphasize_AMRWB_16s_ISfs,(Ipp16s gamma, Ipp16s *pSrcDst,
int len, int ScaleFactor, Ipp16s* pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsAdaptiveCodebookGainCoeff_AMRWB_16s
// Purpose: Compute the adaptive codebook gain
//
// Parameters:
// pSrcAdptTarget: Pointer to the adaptive-codebook vector.
// pSrcFltAdptVector: Pointer to the input filtered adaptive-codebook vector.
// pResultAdptGain: Pointer to the adaptive-codebook gain in the length of 1.
// pResultAdptGainCoeffs Pointer to the output vector in the length 4 represents
// the adaptive-codebook gain as a fraction:
// xy * 2^exp_xy
// gain = -------------
// yy * 2^exp_yy
// where yy = pResultAdptGainCoeffs[0]
// exp_yy = pResultAdptGainCoeffs[1]
// xy = pResultAdptGainCoeffs[2]
// exp_xy = pResultAdptGainCoeffs[3]
// If xy < 0 then pResultAdptGain = 0;
// len length of vectors
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsAdaptiveCodebookGainCoeff_AMRWB_16s,(const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcFltAdptVector, Ipp16s * pDstGainCoeff, Ipp16s * pResultAdptGain, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFQuant_AMRWB_16s
//
// Purpose: Quantizes the ISF coefficient vector, then obtains quantized ISF codebook indices.
// Parameters:
// pSrcIsf - Pointer to the unquantized 16-element ISF vector.
// pSrcDstResidual - Pointer to the 16-element quantized ISF residual from the previous
// frame.
// pDstQIsf - Pointer to the 16-element quantized ISF vector.
// pDstQIsfIndex - Pointer to the 7-element vector of quantized ISP indices. For 6.60 Kbps
// frames only the first five elements contain valid indices,
// for all other bit rates, all seven elements contain valid data
// mode - Bit rate specifier.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsISFQuant_AMRWB_16s,(const Ipp16s *pSrcIsf,
Ipp16s *pSrcDstResidual, Ipp16s *pDstQIsf,
Ipp16s *pDstQIsfIndex, IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFQuantDecode_AMRWB_16s
//
// Purpose: Decodes quantized ISFs from the received codebook index if the
// errors are not detected on the received frame. Otherwise, the
// function recovers the quantized ISFs from previous quantized
// ISFs using linear interpolation.
// Parameters:
// pSrcIdxs - Pointer to the seven-element vector containing codebook indices
// of the quantized LSPs.
// pSrcDstResidual - Pointer to the 16-element quantized ISF residual from
// the previous frame.
// pSrcPrevQntIsf - Pointer to the 16-element quantized ISF vector from the previous
// frame.
// pSrcDstIsfMemory - Pointer to the 64-element vector containing four subframe ISF sets.
// pDstQntIsf - Pointer to a 16-element destination vector containing quantized ISF in frequency domain (0..0.5).
// bfi - Bad frame indicator; "0" signifies a good frame; all other values
// signify a bad frame.
// mode - Bit rate specifier.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsISFQuantDecode_AMRWB_16s,(
const Ipp16s *pSrcIdxs,
Ipp16s *pDstQntIsf,
Ipp16s *pSrcDstResidual,
const Ipp16s *pSrcPrevQntIsf,
Ipp16s *pSrcDstIsfMemory,
int bfi,
IppSpchBitRate mode
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFQuantDTX_AMRWB_16s
//
// Purpose: Quantizes the ISP coefficient vector, then obtains quantized ISP codebook indices in case of DTX mode.
// Parameters:
// pSrcIsf - Pointer to the unquantized 16-element ISF in the frequency domain (0..0.5) vector.
// pDstQntIsf - Pointer to the 16-element quantized ISF vector.
// pDstIdxs - Pointer to the 5-element vector quantization indices.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsISFQuantDTX_AMRWB_16s,(
const Ipp16s *pSrcIsf,
Ipp16s *pDstQntIsf,
Ipp16s *pDstIdxs
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFQuantDecodeDTX_AMRWB_16s
//
// Purpose: Decodes quantized ISFs from the received codebook index in case of DTX mode.
// Parameters:
// pSrcIdxs - Pointer to the 5-element vector quantization indices.
// pDstQntIsf - Pointer to the 16-element ISF in the frequency domain (0..0.5) vector.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsISFQuantDecodeDTX_AMRWB_16s,(
const Ipp16s *pSrcIdxs,
Ipp16s *pDstQntIsf
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSynthesisFilter_AMRWB_16s32s_I
//
// Purpose:
// Parameters:
// pSrcLpc Pointer to the LP coefficients vector.
// order Order of LP filter.
// pSrcExc Pointer to the excitation vector.
// pSrcDst Pointer to the synthesized and updated speech.
// len
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsSynthesisFilter_AMRWB_16s32s_I,(
const Ipp16s *pSrcLpc, int order, const Ipp16s *pSrcExc, Ipp32s *pSrcDstSignal, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDeemphasize_AMRWB
// Purpose: De-emphasis filtering.
// Parameters:
// gamma deemphasis factor.
// pSrc pointer to the input vector
// pDst pointer to the output vector
// pSrcDst pointer to the input/output vector
// pMem memory (pSrcDst[-1])
// len length of input/output vector
*/
IPPAPI(IppStatus, ippsDeemphasize_AMRWB_32s16s,(
Ipp16s gamma, const Ipp32s *pSrc, Ipp16s *pDst, int len, Ipp16s *pMem))
IPPAPI(IppStatus, ippsDeemphasize_AMRWB_NR_16s_I,(
Ipp16s gamma, Ipp16s *pSrcDst, int len, Ipp16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookSearch_AMRWB_16s
//
// Purpose: Performs the adaptive codebook search.
// Parameters:
// pSrcAdptTarget Pointer to the 64-element adaptive target signal vector,
// pSrcImpulseResponse Pointer to the 64-element impulse response of the weighted synthesis
// filter.
// pSrcOpenLoopLag Pointer to a two-element vector of open-loop pitch lags.
// pPitchLag Pointer to output the previous integral pitch lag.
// pPitchLagBounds Pointer to output the previous integral pitch lag bounds.
// pSrcDstExcitation Pointer to the 321-element excitation vector.
// pFracPitchLag Pointer to output the fractional pitch lag obtained during the adaptive codebook
// search.
// pAdptIndex Pointer to output the coded closed-loop pitch index.
// subFrame Subframe number
// mode Coder mode
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAdaptiveCodebookSearch_AMRWB_16s,(
const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcImpulseResponse,
const Ipp16s * pSrcOpenLoopLag,
Ipp16s * pPitchLag,
Ipp16s * pPitchLagBounds,
Ipp16s * pSrcDstExcitation,
Ipp16s * pFracPitchLag,
Ipp16s * pAdptIndex,
int subFrame,
IppSpchBitRate mode))
#if !defined( _OWN_BLDPCS )
typedef struct _AdaptiveCodebookDecodeState_AMRWB_16s IppsAdaptiveCodebookDecodeState_AMRWB_16s;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookDecode
//
// Purpose: This function decodes the adaptive codebook parameters transmitted by the encoder, and then
// applies them to interpolate an adaptive codebook vector.
// valAdptIndex Adaptive codebook index.
// pFracPitchLag Pointer to the fractional pitch lag obtained during the adaptive codebook
// search.
// pResultPrevIntPitchLagBounds Pointer to the previous integral pitch lag bounds.
// pSrcDstExcitation Pointer to the 321-element excitation vector.
// pResultIntPitchLag Pointer to the integral pitch lag.
// subFrame Subframe number
// bfi Bad frame indicator. "0" signifies a good frame; any other value signifies a bad frame.
// unusableFrame
// mode Coder mode
// pState Pointer to the memory supplied for function.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAdaptiveCodebookDecodeGetSize_AMRWB_16s,(int *pDstSize))
IPPAPI(IppStatus, ippsAdaptiveCodebookDecodeInit_AMRWB_16s,(IppsAdaptiveCodebookDecodeState_AMRWB_16s *pState))
IPPAPI(IppStatus, ippsAdaptiveCodebookDecodeUpdate_AMRWB_16s,(int valPitchGain, int valIntPitchLag,
IppsAdaptiveCodebookDecodeState_AMRWB_16s *pState))
IPPAPI(IppStatus, ippsAdaptiveCodebookDecode_AMRWB_16s,(
int valAdptIndex,
Ipp16s * pFracPitchLag,
Ipp16s * pSrcDstExcitation,
Ipp16s * pResultIntPitchLag,
Ipp16s * pResultPrevIntPitchLagBounds,
int subFrame,
int bfi,
int unusableFrame,
IppSpchBitRate mode,
IppsAdaptiveCodebookDecodeState_AMRWB_16s *pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainQuant_AMRWB_16s
// Purpose: Quantization of the adaptive codebook gains
// pSrcAdptTarget - pointer to the input target vector x(n).
// pSrcFltAdptVector - pointer to the input filtered adaptive codebook vector y(n)
// valFormat - format of the pSrcAdptTarget and pSrcFltAdptVector vectors.
// pSrcFixedVector - pointer to the input pre-filtered codebook contribition c(n)
// pSrcFltFixedVector - pointer to the input filtered codebook vector z(n)
// pSrcCorr - pointer to the vector of correlations between pSrcAdptTarget, pSrcFltAdptVector,
// pSrcFltFixedVector vectors.
// pSrcDstEnergyErr - pointer to the input/output energy error vector
// for 4 previous subframes
// pSrcDstPitchGain - Pointer to the input/output pitch gain.
// pDstCodeGain - Pointer to the output code gain.
// valClipFlag - if valClipFlag = 1 then limit gain pitch to 1.0.
// pDstQGainIndex - Pointer to the output codebook indexes found
// lenSrc - Length of the input vectors.
// mode - Coder mode.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsGainQuant_AMRWB_16s,(
const Ipp16s *pSrcAdptTarget, const Ipp16s *pSrcFltAdptVector, int valFormat,
const Ipp16s * pSrcFixedVector, const Ipp16s *pSrcFltFixedVector, const Ipp16s *pSrcCorr,
Ipp16s *pSrcDstEnergyErr, Ipp16s *pSrcDstPitchGain, int *pDstCodeGain,
int valClipFlag, Ipp16s *pDstQGainIndex, int lenSrc, IppSpchBitRate mode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecodeGain_AMRWB_16s
// Purpose: Decode adaptive and fixed-codebook gains
// valQIndex - index of quantization.
// valEnergy - energy of code vector.
// pDstPitchGain - Pointer to decoded pitch gain.
// pDstCodeGain - Pointer to decoded code gain.
// bfi - Bad frame indicator.
// prevBfi - Bad frame indicator of the previous frame.
// pSrcDstPastEnergy - past quantized energies
// pPrevCodeGain - Past code gain.
// pSrcDstPastCodeGain - Past code gain for frame erasures.
// mode - Coder mode.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsDecodeGain_AMRWB_16s,(
int valQIndex,
Ipp32s valEnergy,
Ipp16s *pDstPitchGain,
int *pDstCodeGain,
int bfi,
int prevBfi,
Ipp16s *pSrcDstPastEnergy,
Ipp16s *pPrevCodeGain,
Ipp16s *pSrcDstPastCodeGain,
IppSpchBitRate mode
))
/* /////////////////////////////////////////////////////////////////////////////
// AMRWB end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// AMRWBE related functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookSearch_AMRWBE_16s
//
// Purpose: Performs the adaptive codebook search.
// Parameters:
// pSrcAdptTarget Pointer to the 64-element adaptive target signal vector,
// pSrcImpulseResponse Pointer to the 64-element impulse response of the weighted synthesis
// filter.
// pSrcOpenLoopLag Pointer to a two-element vector of open-loop pitch lags.
// pPitchLag Pointer to output the previous integral pitch lag.
// pPitchLagBounds Pointer to output the previous integral pitch lag bounds.
// pSrcDstExcitation Pointer to the 321-element excitation vector.
// pFracPitchLag Pointer to output the fractional pitch lag obtained during the adaptive codebook
// search.
// pAdptIndex Pointer to output the coded closed-loop pitch index.
// subFrame Subframe number
// mode Coder mode
// pitchOffset Offset for pitch adjustment corresponding internal sampling frequency scale.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAdaptiveCodebookSearch_AMRWBE_16s,(
const Ipp16s * pSrcAdptTarget,
const Ipp16s * pSrcImpulseResponse,
const Ipp16s * pSrcOpenLoopLag,
Ipp16s * pPitchLag,
Ipp16s * pPitchLagBounds,
Ipp16s * pSrcDstExcitation,
Ipp16s * pFracPitchLag,
Ipp16s * pAdptIndex,
int subFrame,
IppSpchBitRate mode,
Ipp16s pitchOffset))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookDecode_AMRWBE_16s
//
// Purpose: This function decodes the adaptive codebook parameters transmitted by the encoder, and then
// applies them to interpolate an adaptive codebook vector.
// Parameters:
// valAdptIndex Adaptive codebook index.
// pSrcDstExcitation Pointer to the 321-element excitation vector.
// pSrcDstPitchLag Pointer to the integral pitch lag.
// pSrcDstFracPitchLag Pointer to the fractional pitch lag obtained during the adaptive
// codebook search.
// pSrcDstPitchLagBounds Pointer to the integral pitch lag bounds.
// subFrame Subframe number
// bfi Bad frame indicator. "0" signifies a good frame; any other value signifies a bad frame.
// pitchOffset Offset for pitch adjustment corresponding internal sampling frequency scale.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAdaptiveCodebookDecode_AMRWBE_16s, (
int valAdptIndex,
Ipp16s* pSrcDstExcitation,
Ipp16s* pSrcDstPitchLag,
Ipp16s* pSrcDstFracPitchLag,
Ipp16s* pSrcDstPitchLagBounds,
int subFrame,
int bfi,
Ipp16s pitchOffset))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainQuant_AMRWBE_16s
// Purpose: Quantization of the adaptive codebook gains
// Parameters:
// pSrcAdptTarget - pointer to the input target vector x(n).
// pSrcFltAdptVector - pointer to the input filtered adaptive codebook vector y(n)
// valFormat - format of the pSrcAdptTarget and pSrcFltAdptVector vectors.
// pSrcFixedVector - pointer to the input pre-filtered codebook contribition c(n)
// pSrcFltFixedVector - pointer to the input filtered codebook vector z(n)
// lenSrc - Length of the input vectors.
// pSrcCorr - pointer to the vector of correlations between pSrcAdptTarget, pSrcFltAdptVector,
// pSrcFltFixedVector vectors [4].
// meanEnergy - The average energy in the whole frame.
// pSrcDstPitchGain - Pointer to the input/output pitch gain.
// pDstCorrFactor - Pointer to the correction factor.
// pDstCodeGain - Pointer to the output code gain.
// pDstQGainIndex - Pointer to the output codebook indexes found
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsGainQuant_AMRWBE_16s,(
const Ipp16s *pSrcAdptTarget, const Ipp16s *pSrcFltAdptVector, int valFormat,
const Ipp16s *pSrcFixedVector, const Ipp16s *pSrcFltFixedVector, int lenSrc,
const Ipp16s *pSrcCorr, Ipp16s meanEnergy, Ipp16s *pSrcDstPitchGain,
Ipp16s* pDstCorrFactor, int *pDstCodeGain, Ipp16s *pDstQGainIndex))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSNR_AMRWBE_16s
// Purpose: Calculate the signal to noise ratio.
// Parameters:
// pSrcSignal Pointer to the input signal.
// pSrcEstimatedSiganl Pointer to the estimated signal.
// lenSrc Length of the signals.
// lenSeg Length of segments (subframes).
// pDstSNR Pointer to the output signal-to-noise ratio in dB.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsSNR_AMRWBE_16s, (const Ipp16s* pSrcSignal,
const Ipp16s* pSrcEstimatedSignal, int lenSrc, int lenSeg, Ipp16s* pDstSNR))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainQuantTCX_AMRWBE_16s
// Purpose: Gain optimization and quantization.
// Parameters:
// pSrcSignal Pointer to the original weighted signal.
// srcScale Format of input signal.
// pSrcQuantSiganl Pointer to the quantized weighted signal.
// len Length of the signals.
// quantFlag If quantFlag = 0, then compute and return optimal gain only,
// else calculate and return quantized gain and quant index.
// pGain Pointer to the output quantized (or optimal) gain.
// pQuantIdx Pointer to the output index of quantization.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsGainQuantTCX_AMRWBE_16s, (const Ipp16s *pSrcSignal,
Ipp16s srcScale, const Ipp16s *pSrcQuantSignal, int len, Ipp32s quantFlag,
Ipp32s *pGain, Ipp16s *pQuantIdx))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainDecodeTCX_AMRWBE_16s
// Purpose: Decode the global TCX gain.
// Parameters:
// pSrcQuantSignal Pointer to the quantized vector.
// lenSrc Length of the input signal.
// quantIdx Index of quantization.
// bfi Bad frame indicator: value "0" signifies a good frame,
// all other values signify a bad frame.
// pSrcDstRMSval Pointer to root mean square value.
// pGain Pointer to the output global TCX gain.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsGainDecodeTCX_AMRWBE_16s, (const Ipp16s *pSrcQuantSignal,
int lenSrc, Ipp16s quantIdx, Ipp32s bfi, Ipp16s *pSrcDstRMSval, Ipp32s *pGain))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFQuantDecode_AMRWBE_16s
//
// Purpose: Decodes quantized ISFs from the received codebook index if the
// errors are not detected on the received frame. Otherwise, the
// function recovers the quantized ISFs from previous quantized
// ISFs using linear interpolation.
// Parameters:
// pSrcIdxs - Pointer to the seven-element vector containing codebook indices
// of the quantized LSPs.
// pSrcDstResidual - Pointer to the 16-element quantized ISF residual from
// the previous frame.
// pSrcPrevQntIsf - Pointer to the 16-element quantized ISF vector from the previous
// frame.
// pSrcDstIsfMemory - Pointer to the 64-element vector containing four subframe ISF sets.
// pDstQntIsf - Pointer to a 16-element destination vector containing quantized
// ISF in frequency domain (0..0.5).
// bfi - Bad frame indicator; "0" signifies a good frame; all other values
// signify a bad frame.
// bfiNext - Bad frame indicator for the next frames.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI( IppStatus, ippsISFQuantDecode_AMRWBE_16s,(
const Ipp16s *pSrcIdxs, Ipp16s *pDstQntIsf, Ipp16s *pSrcDstResidual,
const Ipp16s *pSrcPrevQntIsf, Ipp16s *pSrcDstIsfMemory, int bfi, int bfiNext))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsOpenLoopPitchSearch_AMRWBE_16s
//
// Purpose: Extracts an open-loop pitch lag estimate from the weighted input speech
// Parameters:
// pSrcWgtSpch Pointer to input vector containing perceptually weighted speech.
// pSrcFltWgtSpch Pointer to input vector containing filtered through
// high-pass filter perceptually weighted speech.
// pPrevMedPitchLag Pointer to the median filtered pitch lag of
// the 5 previous voiced speech half-frames.
// pAdaptiveParam Pointer to the adaptive parameter.
// pDstOpenLoopLag Pointer to the open-loop pitch lag.
// pToneFlag Pointer to the tone flag for the VAD module.
// pDstOpenLoopGain Pointer to the optimal open-loop pitch gain.
// pSrcDstPrevPitchLag Pointer to the five-element vector that contains the pitch lags
// associated with the five most recent voiced speech half-frames.
// pSrcDstLagSwitcher Switches lag weighting on and off
// len Length of the frame.
// minPitchLag Minimum pitch lag.
// maxPitchLag Maximum pitch lag.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsOpenLoopPitchSearch_AMRWBE_16s,
(const Ipp16s *pSrcWgtSpch, const Ipp16s * pSrcFltWgtSpch, Ipp16s * pPrevMedPitchLag,
Ipp16s * pAdaptiveParam, Ipp16s * pDstOpenLoopLag, Ipp16s * pToneFlag,
Ipp16s * pDstOpenLoopGain, Ipp16s * pSrcDstPrevPitchLag, Ipp16s * pSrcDstLagSwitcher,
int len, Ipp16s minPitchLag, Ipp16s maxPitchLag))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLPCToISP_AMRWBE_16s
// Purpose: Performs LP to ISP coefficients conversion.
// Parameters:
// pSrcLpc Pointer to the input predictor coefficients.
// pDstIsp Pointer to the output immittance spectral pairs.
// pSrcPrevIsp Pointer to the input previous immittance spectral pairs.
// lpOrder Order of convertion.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLPCToISP_AMRWBE_16s, (const Ipp16s *pSrcLpc,
const Ipp16s *pSrcPrevIsp, Ipp16s *pDstIsp, int lpOrder))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsResamplePolyphase_AMRWBE_16s
// Purpose: Oversample or downsample input signal to/from upper frequency (44.1/48 khz).
// Parameters:
// pSrcSignal Pointer to the signal to resample.
// len Length of input signal.
// upFactor Upsampling factor.
// downFactor Downsampling factor.
// pIntrepFracMem Pointer to the memory of interpolation fraction.
// pMem Pointer to resampling memory. Length is 144 for decimating
// mode, or 44 for oversampling mode.
// pDstSignal Pointer to the resampled signal.
// lenDst Length of resampling signal.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsResamplePolyphase_AMRWBE_16s, (const Ipp16s *pSrcSignal,
int lenSrc, Ipp16s upFactor, Ipp16s downFactor, Ipp16s *pInterpFracMem,
Ipp16s *pMem, Ipp16s *pDstSignal, int lenDst))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsBandSplit_AMRWBE_16s
// Purpose: Split the signal to low and high frequency components.
// Parameters:
// pSrcSignal Poineter to src vector [len + 2*64].
// pSrcDstSig2k Poineter to srcdst low frequency vector [len*5/32 + 2*10].
// pDstSigHi Poineter to dst high frequency vector [len].
// len Length of the sample.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsBandSplit_AMRWBE_16s, (const Ipp16s* pSrcSignal,
Ipp16s* pSrcDstSig2k, Ipp16s* pDstSigHi, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsBandJoin_AMRWBE_16s
// Purpose: Join low and high frequency signals.
// Parameters:
// pSrcSig2k Poineter to src low frequency vector [len*5/32 + 2*10].
// pSrcSigHi Poineter to src high frequency vector [len].
// pDstSignal Poineter to dst vector [len].
// len Length of the sample.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsBandJoin_AMRWBE_16s, (const Ipp16s* pSrcSig2k,
const Ipp16s* pSrcSigHi, Ipp16s* pDstSignal, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsBandJoinUpsample_AMRWBE_16s
// Purpose: Join high and low frequency signals and upsample.
// Parameters:
// pSrcSigLF Pointer to LF signal.
// pSrcSigHF Pointer to HF signal.
// lenSrc Length of LF and HF vectors.
// pDstSig Pointer to upsampled signal.
// lenOut Length of output vector.
// pMem Resampling memory [72].
// pInterFracMem Interpolating fraction memory.
// pCountSamp Number of oversampled samples.
// upsampScale Upsampling frequency scale.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsBandJoinUpsample_AMRWBE_16s, (const Ipp16s* pSrcSigLF,
const Ipp16s* pSrcSigHF, int lenSrc, Ipp16s* pDstSig, int lenDst,
Ipp16s* pMem, Ipp16s* pInterFracMem, Ipp32s* pCountSamp, Ipp16s upsampScale))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsBandSplitDownsample_AMRWBE_16s
// Purpose: Decimate input signal and split to high and low frequency components.
// Parameters:
// pSrcSig Pointer to decimating signal.
// lenSrc Lenth of the input vector.
// pDstSigLF Pointer to LF decimated signal.
// pDstSigHF Pointer to HF decimated signal.
// lenDst Length of LF and HF vectors.
// pMem Decimating memory [1608].
// pInterFracMem Interpolating fraction memory.
// pCountSamp Number of decimated samples.
// upsampScale Upsampling frequency scale.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsBandSplitDownsample_AMRWBE_16s, (const Ipp16s* pSrcSig, int lenSrc,
Ipp16s* pDstSigLF, Ipp16s* pDstSigHF, int lenDst, Ipp16s* pMem,
Ipp16s *pInterFracMem, Ipp32s* pCountSamp, Ipp16s upsampScale))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsUpsample_AMRWBE_16s
// Purpose: Signal oversampling.
// Parameters:
// pSrcSignal Pointer to signal for oversampling.
// pSrcDstSignal Pointer to oversampled signal.
// lenDst Length of output vector.
// pMem Pointer to oversampling memory [24].
// bandIdx Index of interpolating band: 0 for 0..6.4k band, 1 for 6.4..10.8k.
// addFlag Flag for adding operation. 1 if result is added to output
// vector, 0 if not.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsUpsample_AMRWBE_16s, (const Ipp16s* pSrcSignal,
Ipp16s* pSrcDstSignal, int lenDst, Ipp16s* pMem, Ipp32s bandIdx, Ipp32s addFlag))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDownsample_AMRWBE_16s
// Purpose: Signal decimating.
// Parameters:
// pSrcSignal Pointer to decimating signal.
// lenSrc Length of input vector
// pDstSignal Pointer to decimated signal [1024].
// pMem Pointer to decimating memory [46].
// bandIdx Index of interpolating band: 0 for 0..6.4k band, 1 for 6.4..10.8k.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsDownsample_AMRWBE_16s, (const Ipp16s* pSrcSignal, int lenSrc,
Ipp16s*pDstSignal, Ipp16s* pMem, Ipp32s bandIdx))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFQuantHighBand_AMRWBE_16s
// Purpose: ISF quantization of HF-band encoded signal.
// Parameters:
// pSrcISF Pointer to the vector of proceeding ISF [8].
// pSrcDstPastQISF Pointer to the past quantized ISF [8].
// pDstQISF Pointer to the output vector of quantized ISF [8].
// pQuantIdxs Pointer to the output quantization indices [2].
// pitchAdjust Pitch adjustment flag (if null, pitch adjustment is not
// implements, else any other).
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsISFQuantHighBand_AMRWBE_16s, (const Ipp16s *pSrcISF,
Ipp16s *pSrcDstPastQISF, Ipp16s *pDstQISF, Ipp16s *pQuantIdxs, Ipp32s pitchAdjust))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsISFQuantDecodeHighBand_AMRWBE_16s
// Purpose: Decode quantized ISF of HF-band signal.
// Parameters:
// pQuantIdxs Pointer to the quantization indices [2].
// pSrcDstPastQISF Pointer to the past quantized ISF [8].
// pDstQISF Pointer to the output vector of decoded quantized ISF [8].
// bfi Bad frame indicator: value "0" signifies a good frame,
// all other values signify a bad frame.
// pitchAdjust Pitch adjustment flag (if null, pitch adjustment
// is not implements, else any other).
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsISFQuantDecodeHighBand_AMRWBE_16s, (const Ipp16s *pSrcQuantIdxs,
Ipp16s *pSrcDstPastQISF, Ipp16s *pDstQISF, Ipp32s bfi, Ipp32s pitchAdjust))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTFwd_RToPerm_AMRWBE_16s
// Purpose: Computes the forward fast Fourier transform (FFT) of a real signal.
// Parameters:
// pSrc Pointer to the real-valued sequence.
// pDst Pointer to the transform result.
// len Length of the sequence (48, 96, 192 for Radix-3 algorithm
// or 288, 576, 1152 for Radix-9 algorithm).
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsFFTFwd_RToPerm_AMRWBE_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTInv_PermToR_AMRWBE_16s
// Purpose: Computes the inverse fast Fourier transform (FFT) of a real signal.
// Parameters:
// pSrc Pointer to the transform coefficients.
// pDst Pointer to the real-valued sequence.
// len Length of the sequence (48, 96, 192 for Radix-3 algorithm
// or 288, 576, 1152 for Radix-9 algorithm).
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsFFTInv_PermToR_AMRWBE_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSynthesisFilter_AMRWBE_16s32s_I
//
// Purpose:
// Parameters:
// pSrcLpc Pointer to the LP coefficients vector.
// order Order of LP filter.
// pSrcExc Pointer to the excitation vector.
// pSrcDst Pointer to the synthesized and updated speech.
// len
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsSynthesisFilter_AMRWBE_16s32s_I,(
const Ipp16s *pSrcLpc, int order, const Ipp16s *pSrcExc, Ipp32s *pSrcDstSignal, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDeemphasize_AMRWBE_NR_16s_I
// Purpose: Performs de-emphasis filtering.
// Parameters:
// gamma De-emphasis factor.
// gammaScale Scale factor for gamma.
// pSrcDst Pointer to the input/output vector.
// len Length of the input/output vector.
// pMem Pointer to the filter memory element.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsDeemphasize_AMRWBE_NR_16s_I, (Ipp16s gamma,
Ipp32s gammaScale, Ipp16s *pSrcDstSignal, int len, Ipp16s *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFIRGenMidBand_AMRWBE_16s
// Purpose: Compute a shape-constrained FIR filter using the covariance method.
// Parameters:
// pSrcSignal Pointer to the signal [-8...(256+64)]
// pSrcSideSignal Pointer to the real side signal [256+64].
// pTaps Pointer to the FIR coefficients of length [9].
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsFIRGenMidBand_AMRWBE_16s, (const Ipp16s* pSrcSignal,
const Ipp16s* pSrcSideSignal, Ipp16s* pTaps))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilterLowBand_AMRWBE_16s
// Purpose: Post-processing of low-band decoded signal.
// Parameters:
// pSrcOldPitchLag Pointer to the previous pitch periods for all subframes [16].
// pSrcOldPitchGain Pointer to the previous pitch gains for all subframes [16].
// pSrcDstSignal Pointer to the proceeding signal [1024].
// pOldSynth Pointer to the synthesis memory of post-filter [503].
// pOldNoise Pointer to the noise memory of post-filter [24].
// pFilterScale Pointer to the noise memory of post-filter scale factor.
// pitchAdjust Pitch adjustment flag (if null, pitch adjustment is not
// implements, else any other).
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsPostFilterLowBand_AMRWBE_16s, (const Ipp16s *pSrcOldPitchLag,
const Ipp16s *pSrcOldPitchGain, Ipp16s *pSrcDstSignal, Ipp16s *pOldSynth,
Ipp16s *pOldNoise, Ipp16s *pFilterScale, Ipp32s pitchAdjust))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQuantTCX_AMRWBE_16s
// Purpose: Quantize the pre-shaped spectrum in TCX mode.
// Parameters:
// pSrc Pointer to the signal to quatize [nSubvectors*8].
// pDst Pointer to quantized normalized vector [nSubvectors*8+nSubvectors].
// nSubvectors Number of subvectors.
// nBits Number of bits to use.
// pDstNoiseFactor Pointer to the comfort noise gain factor.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsQuantTCX_AMRWBE_16s, (const Ipp16s *pSrc, Ipp16s *pDst,
int nSubvectors, int nBits, Ipp16s* pDstNoiseFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEncodeMux_AMRWBE_16s
// Purpose: Encode and multiplex subvectors into several packets.
// Parameters:
// pSrc Pointer to rounded subvectors [nSubvectors*8+nSubvectors].
// nSubvectors Number of subvectors.
// pPacketSizes Pointer to vector of each packet size [nPackets].
// pDstParams Multiplexed parameters
// [(pPacketSizes[0]+3)/4+...+(pPacketSizes[nPackets]+3)/4].
// nPackets Number of packets.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsEncodeMux_AMRWBE_16s, (const Ipp16s *pSrc, int nSubvectors,
const int *pPacketSizes, Ipp16s *pDstParams, int nPackets))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDecodeDemux_AMRWBE_16s
// Purpose: Demultiplex and decode subvectors from several packets.
// Parameters:
// pSrcParams Demultiplex parameters [(pPacketSizes[0]+3)/4+...+(pPacketSizes[nPackets]+3)/4].
// pPacketSizes Pointer to vector of each packet size [nPackets].
// pBFI Pointer to vector of bad frame indicators for each packet [nPackets].
// nPackets Number of packets.
// pDst Pointer to rounded subvectors [nSubvectors*8].
// nSubvectors Number of subvectors.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsDecodeDemux_AMRWBE_16s, (const Ipp16s *pSrcParams,
const Ipp32s *pPacketSizes, const Ipp32s* pBFI, int nPackets,
Ipp16s *pDst, int nSubvectors))
/* /////////////////////////////////////////////////////////////////////////////
// AMRWBE end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// G722 SBADPCM related functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
struct EncoderState_G722_16s;
typedef struct EncoderState_G722_16s IppsEncoderState_G722_16s;
struct DecoderState_G722_16s;
typedef struct DecoderState_G722_16s IppsDecoderState_G722_16s;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSBADPCMEncodeStateSize_G722_16s
// Purpose: Returns the G722 SBADPCM encoder state memory size
// pEncMemSize - pointer to the output encoder state memory size in bytes.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsSBADPCMEncodeStateSize_G722_16s, (int* pEncMemSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSBADPCMEncodeInit_G722_16s
// Purpose: This function initializes the memory buffer referenced by the pointer pEncMem.
// pEncMem - pointer to the input memory buffer of size required to properly initialize the encoder.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsSBADPCMEncodeInit_G722_16s, (IppsEncoderState_G722_16s* pEncMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSBADPCMEncode_G722_16s
// Purpose: Encode lower and upper sub-band of incoming speech or music.
// pSrc - pointer to the input vector of synthesis QMF samples.
// pDst - pointer to the ADPCM bit-stream output vector.
// len - the length of input vector, must be a multiple of two.
// pEncMem - pointer to the state memory of the Sub-Band ADPCM encoder.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsSBADPCMEncode_G722_16s, (const Ipp16s *pSrc, Ipp16s *pDst,
int len, IppsEncoderState_G722_16s* pEncMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFEncode_G722_16s
// Purpose: This function uses Quadrature Mirror Filtering (QMF) of the 14-bit
// uniform PCM speech input to compute the lower and higher sub-band signal
// components for the Sub-Band ADPCM encoder.
// pSrc - pointer to the uniform PCM input speech vector.
// pDst - pointer to the synthesis QMF samples output vector.
// len - the length of input/output vectors, must be a multiple of two.
// delay - pointer to the buffer of a delay line.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsQMFEncode_G722_16s,
(const Ipp16s *pSrc, Ipp16s *pDst, int len, Ipp16s *delay))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSBADPCMDecodeStateSize_G722_16s
// Purpose: Returns the G722 SBADPCM decoder state memory size
// pDecMemSize - pointer to the output decoder state memory size in bytes.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsSBADPCMDecodeStateSize_G722_16s, (int* pDecMemSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSBADPCMDecodeInit_G722_16s
// Purpose: Initializes the memory buffer referenced by the pointer pDecMem.
// pDecMem - Pointer to the input decoder state memory buffer
// of size required to properly initialize the decoder.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsSBADPCMDecodeInit_G722_16s, (IppsDecoderState_G722_16s *pDecMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSBADPCMDecode_G722_16s
// Purpose: Decode lower sub-band of input audio signal.
// pSrc - pointer to the input vector that contains unpacked
// lower and high ADPCM 16bit samples given in pair.
// pDst - Pointer to the output vector that contains decoded low-
// and high- bands portions of the recovered audio samples.
// len - the length of the input vector, must be multiple of two.
// mode - decode bit rate of the G.722 decoder.
// pDecMem - pointer to the state memory of the Sub-Band ADPCM decoder.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsSBADPCMDecode_G722_16s, (const Ipp16s *pSrc, Ipp16s *pDst,
int len, Ipp16s mode, IppsDecoderState_G722_16s * pDecMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFDecode_G722_16s
// Purpose: This function performs Quadrature Mirror Filter (QMF) synthesis
// of the low- and high- bands portions of the recovered samples
// to reconstruct the output signal.
// pSrc - pointer to the input vector that contains decoded low- and high- bands
// portions of the recovered samples.
// pDst - pointer to the output vector of 16bit linear PCM audio samples.
// len - the length of input/output vectors, must be a multiple of two.
// delay - pointer to the buffer of a delay line.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsQMFDecode_G722_16s,
(const Ipp16s *pSrc, Ipp16s *pDst, int len, Ipp16s *delay))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSBADPCMDecodeStateUpdate_G722_16s
// Purpose: This function updates the state of the sub-band ADPCM decoder
// after extrapolating missing frames to help in recovery from frame erasures.
// pCoeffs - First-order pole zero filter coefficients array.
// gainFactor - Attenuation factor for gains.
// resetDelayFlag - If 0: no delays reset, otherwise reset delays.
// pDecMem - Pointer to the state memory of the Sub-Band ADPCM decoder.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsSBADPCMDecodeStateUpdate_G722_16s, (const Ipp16s pCoeffs[2], Ipp16s gainFactor,
int resetDelayFlag, IppsDecoderState_G722_16s *pDecMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsClassifyFrame_G722_16s_I
// Purpose: Classify the frame and modify the residual signal by the condition.
// pSrcDst - Pointer to the excitation vector [(valDelay*2)+2].
// valDelay - The pitch delay estimated by the LTP analysis.
// pClass - Pointer to the frame class.
// pDecMem - Pointer to the state memory of the Sub-Band ADPCM decoder.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsClassifyFrame_G722_16s_I, (Ipp16s *pSrcDst, Ipp16s valDelay, IppG722SBClass *pSrcDstClass,
IppsDecoderState_G722_16s *pDecMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterHighband_G722_16s_I
// Purpose: This function filters higher band part of the input array pSrcDst
// through the first-order high-pass filter with memory pMem and stores
// the results in pSrcDst. The filter memory pMem is updated and shoud
// be used for filtering of the next frame.
// pSrcDst - Pointer to the source and destination vector [len].
// len - Number of elements in the source and destination vector.
// pMem - Pointer to the filter memory array
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsFilterHighband_G722_16s_I, (Ipp16s *pSrcDst, int len, Ipp16s pMem[2]))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDownsampleFilter_G722_16s
// Purpose: This function down-samples the input vector by a factor of 4,
// by using low-pass filter and decimating their values at the same time.
// pSrc - Pointer to the source vector [lenSrc].
// lenSrc - Length of the source vector.
// pDst - Pointer to the destination vector[lenSrc/4].
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsDownsampleFilter_G722_16s, (const Ipp16s *pSrc, int lenSrc, Ipp16s *pDst))
/* /////////////////////////////////////////////////////////////////////////////
// G722 SBADPCM end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Echo Canceller related functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
struct _SubbandProcessState_32f;
typedef struct _SubbandProcessState_32f IppsSubbandProcessState_32f;
struct _SubbandControllerState_EC_32f;
typedef struct _SubbandControllerState_EC_32f IppsSubbandControllerState_EC_32f;
struct _FullbandControllerState_EC_32f;
typedef struct _FullbandControllerState_EC_32f IppsFullbandControllerState_EC_32f;
struct _ToneDetectState_EC_32f;
typedef struct _ToneDetectState_EC_32f IppsToneDetectState_EC_32f;
struct _SubbandProcessState_16s;
typedef struct _SubbandProcessState_16s IppsSubbandProcessState_16s;
struct _SubbandControllerState_EC_16s;
typedef struct _SubbandControllerState_EC_16s IppsSubbandControllerState_EC_16s;
struct _FullbandControllerState_EC_16s;
typedef struct _FullbandControllerState_EC_16s IppsFullbandControllerState_EC_16s;
struct _ToneDetectState_EC_16s;
typedef struct _ToneDetectState_EC_16s IppsToneDetectState_EC_16s;
struct _SubbandControllerDTState_EC_16s;
typedef struct _SubbandControllerDTState_EC_16s IppsSubbandControllerDTState_EC_16s;
#endif /* _OWN_BLDPCS */
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandProcessGetSize
//
// Purpose:
// Returns size of the state structure
//
// Parameters:
// order Number of subbands = (2 ^ (order - 1) + 1)
// windowLen Length of window
// pStateSize Pointer to the computed value of size of buffer
// for state structure.
// pInitBufSize Pointer to the computed size of buffer for use
// in initialization function
// pBufSize Pointer to the computed size of work buffer.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when pSize is NULL.
// ippStsBadArgErr Indicates an error when order is less than or
// equal to 0 or windowLen is not divisibly by 2 ^
// order
*/
IPPAPI(IppStatus, ippsSubbandProcessGetSize_32f, (int order, int windowLen,
int *pSize, int *pInitBufSize, int *pBufSize))
IPPAPI(IppStatus, ippsSubbandProcessGetSize_16s, (int order, int windowLen,
int *pSize, int *pInitBufSize, int *pBufSize))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandProcessInit
//
// Purpose:
// Initializes the state structure
//
// Parameters:
// pState Pointer to the state structure to be created
// order Number of subbands = (2 ^ (order - 1) + 1)
// frameSize Size of frame. Should be in range [1, 2 ^order]
// windowLen Window length
// pWindow Pointer to window coefficients (may be NULL, if
// the order, frameSize and windowLen are equal to
// one of the predefined values: (5, 24, 128) or
// (6, 44, 256). In this case the predefined
// window is used.
// pInitBuf Pointer to the init buffer
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when buf or pState is NULL.
// ippStsBadArgErr Indicates an error when order is less or equal
// to 0 or windowLen is not divisibly by 2 ^ order
// or frameSize is less than or equal to 0 or (
// window is NULL and appropriate internal window
// doesn't exist).
*/
IPPAPI(IppStatus, ippsSubbandProcessInit_32f, (
IppsSubbandProcessState_32f *state,
int order, int frameSize, int windowLen, const Ipp32f *pWindow,
Ipp8u *pInitBuf))
IPPAPI(IppStatus, ippsSubbandProcessInit_16s, (
IppsSubbandProcessState_16s *state,
int order, int frameSize, int windowLen, const Ipp16s *pWindow,
Ipp8u *pInitBuf))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandAnalysis
//
// Purpose:
// Decomposes frame into complex subband representation
//
// Parameters:
// pSignal Pointer to the source vector of the length equal
// to the frame size which was used to initialize
// the subband process algorithm by
// ippsSubbandProcessInit function.
// pSubbands Pointer to the subband results vector of the
// length equal to number of subbands, calculated
// as (2 ^ (order - 1) + 1), where order is
// specified in ippsSubbandProcessInit.
// pState Pointer to the state structure
// pBuf Pointer to work buffer, user to allocate of size
// specified by the parameter pBufSise
// ippsSubbandProcessGetSize function.
// scalefactor scale factor value
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsSubbandAnalysis_32f32fc, (const Ipp32f *pSignal, Ipp32fc *pSubbands,
IppsSubbandProcessState_32f *pState, Ipp8u *pBuf))
IPPAPI(IppStatus, ippsSubbandAnalysis_16s32sc_Sfs, (const Ipp16s *pSignal, Ipp32sc *pSubbands,
IppsSubbandProcessState_16s *pState, int scalefactor, Ipp8u *pBuf))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandSynthesis
//
// Purpose:
// Reconstructs frame from complex subband representation
//
// Parameters:
// pSubbands Pointer to the subband results vector of the
// length equal to number of subbands, calculated
// as (2 ^ (order - 1) + 1), where an order is
// specified in ippsSubbandProcessInit
// pSignal Pointer to the destination signal vector of the
// length equal to frame size which was used to
// initialize the subband process algorithm by
// ippsSubbandProcessInit function.
// pState Pointer to the state structure
// pBuf Pointer to the work buffer of size after the
// ippsSubbandProcessGetSize function call (to be
// returned via pBufSize parameter)
// scalefactor scale factor value
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsSubbandSynthesis_32fc32f, (const Ipp32fc *pSubbands, Ipp32f *pSignal,
IppsSubbandProcessState_32f *pState, Ipp8u *pBuf))
IPPAPI(IppStatus, ippsSubbandSynthesis_32sc16s_Sfs, (const Ipp32sc *pSubbands, Ipp16s *pSignal,
IppsSubbandProcessState_16s *pState, int scalefactor, Ipp8u *pBuf))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandControllerGetSize_EC
//
// Purpose:
// Returns size of the state structure
//
// Parameters:
// numSubbands Number of subbands
// frameSize Size of frame
// numSegments Number of segments
// sampleFreq Sample frequency
// pSize Pointer to the computed buffer size value.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when pSize NULL.
// ippStsRangeErr Indicates an error when sampleFreq is not a valid element
// of the enumerated type IppPCMFrequency.
// ippStsBadArgErr Indicates an error when numSubbands is less or
// equal to 0 or numSegment is less than or equal
// to 0 or frameSize is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsSubbandControllerGetSize_EC_32f, (int numSubbands, int frameSize,
int numSegments, IppPCMFrequency sampleFreq, int *pSize))
IPPAPI(IppStatus, ippsSubbandControllerGetSize_EC_16s, (int numSubbands, int frameSize,
int numSegments, IppPCMFrequency sampleFreq, int *pSize))
IPPAPI(IppStatus, ippsSubbandControllerDTGetSize_EC_16s, (int numSubbands, int frameSize,
int numSegments, IppPCMFrequency sampleFreq, int *pSize))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandControllerInit_EC
//
// Purpose:
// Initializes the state structure
//
// Parameters:
// pState Pointer to the state structure to be created
// numSubbands Number of subbands
// frameSize Size of frame
// numSegments Number of segments
// sampleFreq Sample frequency.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
// ippStsRangeErr Indicates an error when sampleFreq is not a valid element
// of the enumerated type IppPCMFrequency.
// ippStsBadArgErr Indicates an error when numSubbands is less or
// equal to 0 or numSegment is less than or equal
// to 0 or frameSize is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsSubbandControllerInit_EC_32f, (IppsSubbandControllerState_EC_32f *pState,
int numSubbands, int frameSize, int numSegments, IppPCMFrequency sampleFreq))
IPPAPI(IppStatus, ippsSubbandControllerInit_EC_16s, (IppsSubbandControllerState_EC_16s *pState,
int numSubbands, int frameSize, int numSegments, IppPCMFrequency sampleFreq))
IPPAPI(IppStatus, ippsSubbandControllerDTInit_EC_16s, (IppsSubbandControllerDTState_EC_16s *pState,
int numSubbands, int frameSize, int numSegments, IppPCMFrequency sampleFreq))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandControllerUpdate_EC
//
// Purpose:
// Updates controller state. Returns step sizes.
//
// Parameters:
// pSrcRin Pointer to receive-in signal frame.
// pSrcSin Pointer to send-in signal frame. Frame size is
// specified in ippsSubbandControllerInit function
// ppSrcRinSubbandsHistory Pointer to an array of pointers to the most
// recent receive-in blocks. Size of array is equal
// to numSegments, specified in
// ippsSubbandControllerInit_EC function
// pSrcSinSubbands Pointer to subband representation of send-in
// signal frame (or NULL). Size of array =
// numSubbands, specified in
// ippsSubbandControllerInit_EC function
// pDstStepSize Pointer to step sizes. Length of vector =
// numSubbands, specified in
// ippsSubbandControllerInit_EC function
// learningRate Positive value 0-1, learning rate parameter.
//
// pState Pointer to structure
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when pState, pRin, pSin,
// pRinSubbands or pStepSize is NULL.
*/
IPPAPI(IppStatus, ippsSubbandControllerUpdate_EC_16s, (const Ipp16s *pSrcRin, const Ipp16s *pSrcSin,
const Ipp32sc **ppSrcRinSubbandsHistory, const Ipp32sc *pSrcSinSubbands,
Ipp32s_EC_Sfs *pDstStepSize, IppsSubbandControllerState_EC_16s *pState))
IPPAPI(IppStatus, ippsSubbandAPControllerUpdate_EC_32f,(
const Ipp32fc **ppSrcRinSubbandsHistory, const Ipp32fc *pSrcSinSubbands,
double *pDstStepSize, Ipp32f learningRate, IppsSubbandControllerState_EC_32f *pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandController_EC
//
// Purpose:
// Main controller function. Updates coefficients of filters. Returns
// output gain coefficients
//
// Parameters:
// pSrcAdaptiveFilterErr Pointer to the adaptive filter error vector of
// length equal to numSubbands, specified in
// ippsSubbandControllerInit_EC function
// pSrcFixedFilterErr Pointer to errors of fixed filter. Length is
// equal to numSubbands
// ppDstAdaptiveCoefs Pointer to an array of pointers to the filter
// Length of array coefficients vectors =
// numSegments, specified in
// ippsSubbandControllerInit_EC
// ppDstFixedCoefs Pointer to an array of pointers to the filter
// Length of array coefficients vectors =
// numSegments, specified in
// ippsSubbandControllerInit_EC
// pDstSGain Pointer to send gain coefficient
// pState Pointer to SubbandController_EC state structure.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsSubbandControllerUpdate_EC_32f, (const Ipp32f *pSrcRin, const Ipp32f *pSrcSin,
const Ipp32fc **ppSrcRinSubbandsHistory, const Ipp32fc *pSrcSinSubbands,
double *pDstStepSize, IppsSubbandControllerState_EC_32f *pState))
IPPAPI(IppStatus, ippsSubbandController_EC_32f, (const Ipp32fc *pSrcAdaptiveFilterErr,
const Ipp32fc *pSrcFixedFilterErr,
Ipp32fc **ppDstAdaptiveCoefs, Ipp32fc **ppDstFixedCoefs,
Ipp32f *pDstSGain, IppsSubbandControllerState_EC_32f *pState))
IPPAPI(IppStatus, ippsSubbandController_EC_16s, (const Ipp32sc *pSrcAdaptiveFilterErr,
const Ipp32sc *pSrcFixedFilterErr,
Ipp32sc **ppDstAdaptiveCoefs, Ipp32sc **ppDstFixedCoefs,
Ipp16s *pDstSGain, IppsSubbandControllerState_EC_16s *pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandControllerReset_EC
//
// Purpose:
// Resets controller state
//
// Parameters:
// pState Pointer to the structure.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsSubbandControllerReset_EC_32f, (IppsSubbandControllerState_EC_32f *pState))
IPPAPI(IppStatus, ippsSubbandControllerReset_EC_16s, (IppsSubbandControllerState_EC_16s *pState))
IPPAPI(IppStatus, ippsSubbandControllerDTReset_EC_16s, (IppsSubbandControllerDTState_EC_16s *pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFullbandControllerGetSize_EC
//
// Purpose:
// Returns size of the state structure
//
// Parameters:
// frameSize Size of frame
// tapLen Number of tap values.
// sampleFreq Sample frequency
// pSize Pointer to the computed buffer size value.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when pSize NULL.
// ippStsRangeErr Indicates an error when sampleFreq is not a valid element
// of the enumerated type IppPCMFrequency.
// ippStsBadArgErr Indicates an error when frameSize is less or
// equal to 0 or tapLen is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsFullbandControllerGetSize_EC_32f, (int frameSize,
int tapLen, IppPCMFrequency sampleFreq, int *pSize))
IPPAPI(IppStatus, ippsFullbandControllerGetSize_EC_16s, (int frameSize,
int tapLen, IppPCMFrequency sampleFreq, int *pSize))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFullbandControllerInit_EC
//
// Purpose:
// Initializes the state structure
//
// Parameters:
// pState Pointer to the memory buffer for the fullband
// controller state structure to be initialized.
// The size of the memory buffer to be acquired by
// ippsFullbandControllerGetSize_EC function via
// pSize parameter.
// frameSize Size of frame
// tapLen Number of tap values.
// sampleFreq Sample frequency.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
// ippStsRangeErr Indicates an error when sampleFreq is not a valid element
// of the enumerated type IppPCMFrequency.
// ippStsBadArgErr Indicates an error when frameSize is less or
// equal to 0 or tapLen is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsFullbandControllerInit_EC_32f, (IppsFullbandControllerState_EC_32f *pState,
int frameSize, int tapLen, IppPCMFrequency sampleFreq))
IPPAPI(IppStatus, ippsFullbandControllerInit_EC_16s, (IppsFullbandControllerState_EC_16s *pState,
int frameSize, int tapLen, IppPCMFrequency sampleFreq))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFullbandControllerUpdate_EC
//
// Purpose:
// Updates controller state. Returns step sizes
//
// Parameters:
// pSrcRin Pointer to receive-in signal history,length =
// tapLen + frameSize, tapLen and frameSize is
// specified in ippsFullbandControllerInit
// pSrcSin Pointer to send-in signal frame, frame size is
// specified in ippsFullbandControllerInit_EC
// pDstStepSize Pointer to step sizes, length = frame_size,
// specified in ippsFullbandControllerInit_EC
// pState Pointer to structure
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when pState, pRin, pSin, or
// pStepSize is NULL.
*/
IPPAPI(IppStatus, ippsFullbandControllerUpdate_EC_32f, (const Ipp32f *pSrcRin,
const Ipp32f *pSrcSin, Ipp32f *pDstStepSize,
IppsFullbandControllerState_EC_32f *pState))
IPPAPI(IppStatus, ippsFullbandControllerUpdate_EC_16s, (const Ipp16s *pSrcRin,
const Ipp16s *pSrcSin, Ipp32s *pDstStepSize,
IppsFullbandControllerState_EC_16s *pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFullbandController_EC
//
// Purpose:
// Main controller function. Updates coefficients of filter . Returns
// output gain coefficients
//
// Parameters:
// pState Pointer to structure.
// pAdaptiveFilterErr Pointer to output of path with adaptive filter,
// length = frame size , specified in
// ippsFullbandControllerInit_EC
// pFixedFilterErr Pointer to output of path with fixed filter.
// length = frame size, specified in
// ippsFullbandControllerInit_EC
// pAdaptiveCoefs Pointer to the filter coefficients vectors.
// length = tapLength, specified in
// ippsFullbandControllerInit_EC
// pFixedCoefs Pointer to the filter coefficients vectors.
// length = tapLength, specified in
// ippsFullbandControllerInit_EC
// pSGain Pointer to send gain coefficient
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsFullbandController_EC_32f, (const Ipp32f *pAdaptiveFilterErr,
const Ipp32f *pFixedFilterErr,
Ipp32f *pAdaptiveCoefs, Ipp32f *pFixedCoefs,
Ipp32f *pSGain,
IppsFullbandControllerState_EC_32f *pState))
IPPAPI(IppStatus, ippsFullbandController_EC_16s, (const Ipp16s *pAdaptiveFilterErr,
const Ipp16s *pFixedFilterErr,
Ipp16s *pAdaptiveCoefs, Ipp16s *pFixedCoefs,
Ipp16s *pSGain,
IppsFullbandControllerState_EC_16s *pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFullbandControllerReset_EC
//
// Purpose:
// Resets controller state
//
// Parameters:
// pState Pointer to the structure.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsFullbandControllerReset_EC_32f, (IppsFullbandControllerState_EC_32f *pState))
IPPAPI(IppStatus, ippsFullbandControllerReset_EC_16s, (IppsFullbandControllerState_EC_16s *pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFIR_EC
//
// Purpose:
// Computes FIR filtering results.
//
// Parameters:
// pSrcSpchRef Pointer to the source original (receive-out)
// signal of (tapLength + len) length
// pSrcSpch Pointer to the signal with echo path (send-in)
// pDstSpch Pointer to the destination "echo-free" signal
// (send-out)
// len Length of source and destination signals
// pSrcTaps FIR filter taps vector
// tapsLen Number of taps of the FIR filter
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsFIR_EC_32f, (const Ipp32f *pSrcSpchRef,
const Ipp32f *pSrcSpch,
Ipp32f *pDstSpch,
int len,
Ipp32f *pSrcCoef,
int tapLength))
IPPAPI(IppStatus, ippsFIR_EC_16s, (const Ipp16s *pSrcSpchRef,
const Ipp16s *pSrcSpch,
Ipp16s *pDstSpch,
int len,
Ipp16s *pSrcCoef,
int tapLength))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsNLMS_EC
//
// Purpose:
// Performs filtering with coefficients update.
//
// Parameters:
// pSrcSpchRef Pointer to the source original (receive-out)
// signal of (tapLength + len) length.
// pSrcSpch Pointer to the signal with echo path (send-in)
// pStepSize Pointer to step sizes vector of length equal to
// len
// pSrcDstErr Pointer to last error value
// pDstSpch Pointer to the destination "echo-free" signal
// (send-out)
// len Length of source and destination signals
// pSrcDstTaps FIR filter taps source and destination vector
// tapsLen Number of taps
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
*/
IPPAPI(IppStatus, ippsNLMS_EC_32f, (const Ipp32f *pSrcSpchRef,
const Ipp32f *pSrcSpch,
const Ipp32f *pStepSize,
Ipp32f *pDstSpch,
int len,
Ipp32f *pSrcDstCoef,
int tapLength,
Ipp32f *pErr))
IPPAPI(IppStatus, ippsNLMS_EC_16s, (const Ipp16s *pSrcSpchRef,
const Ipp16s *pSrcSpch,
const Ipp32s *pStepSize,
Ipp16s *pDstSpch,
int len,
Ipp16s *pSrcDstCoef,
int tapLength,
Ipp16s *pErr))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFIRSubband_EC
//
// Purpose:
// This function computes the filter output in AEC NLMS algorithm.
//
// Parameters:
// ppSrcSignalIn, ppSrcSignal Pointers to an two-dimensional vector of size
// [numSegments][len] containing the pointers to the most recent
// complex-valued FFT spectra an input audio signal.
// ppSrcCoefs, ppCoefs Pointers to an two-dimensional vector of size [numSegments][len]
// containing the pointers to the filter coefficients vector of size [len].
// pDstSignalOut, pDstSignal Pointers to the complex-valued filter output vector.
// numSegments Number of filter segments (0 < numSegments < 256).
// len, numSubbands Number of filter subbands (0 < len, numSubbands < 4097).
// startSubband Number of subbands to skip before filtering (0<= startSubband < numSubbands)
// scaleFactor Saturation fixed scale factor (-32 < scaleFactor < 32)
// for Low function 0 <= scaleFactor < 32)
//
// Returns:
// ippStsNoErr No Error.
// ippStsNullPtrErr ppSrcSignalIn, ppSrcCoefs or pDstSignalOut is null.
// ippStsLengthErr len is out of range.
// ippStsRangeErr numSegments or scaleFactor is out of range.
//
*/
IPPAPI(IppStatus, ippsFIRSubband_EC_32fc, (
Ipp32fc **ppSrcSignalIn,
Ipp32fc **ppSrcCoefs,
Ipp32fc *pDstSignalOut,
int numSegments,
int len))
IPPAPI(IppStatus, ippsFIRSubband_EC_32sc_Sfs,(
Ipp32sc **ppSrcSignalIn,
Ipp32sc **ppSrcCoefs,
Ipp32sc *pDstSignalOut,
int numSegments,
int len,
int scaleFactor))
IPPAPI(IppStatus, ippsFIRSubbandLow_EC_32sc_Sfs,(
const Ipp32sc** ppSrcSignal,
const Ipp32sc** ppCoefs,
int numSegments,
Ipp32sc* pDstSignal,
int startSubband,
int numSubbands,
int scaleFactor))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsFIRSubbandCoeffUpdate_EC
//
// Purpose:
// This function updates the coefficients of the AEC adaptive
// filter designed based on NLMS algorithm.
// Parameters:
// pSrcStepSize, pSrcAdaptStepSize Pointer to the adaptive filter step size
// vector of size [len] or [numSubbands]. For the integer
// functions step size vector elements are represented
// as a scaled integer values where variable x of type
// Ipp32s_EC_Sfs corresponds to the floating point value
// x.val * 2^x.sf.
// ppSrcStepSize Pointer to the array of pSrcStepSize. See above.
// apOrder affine projection order.
// ppSrcFilterInput Pointer to the array of pointers to the most recent
// input blocks (e.g., Xn, Xn-1,..., Xn-L+1) the complex-valued
// vectors that contain the FFT of the input signal.
// The dimension of ppSrcFilterInput is [numSegments][len]
// or [numSegments][numSubbands].
// ppSrcDstCoefsQ15, ppSrcDstCoefs Pointer to the array of pointers to the filter coefficient
// vectors. These are the complex-valued vectors containing
// the filter coefficients. The dimension of ppSrcDstCoefs
// is [numSegments][len] or [numSegments][numSubbands].
// pSrcError Pointer to the complex-valued vector containing the filter
// error. The dimension of pSrcError is [len] or [numSubbands].
// ppSrcError Pointer to the array of pSrcError. See above.
// numSegments Number of filter segments (0 < numSegments < 256).
// len, numSubbands Number of adaptive filter subbands and length of the input
// and output vectors.
// pDstProdStepErrQ Pointer to the output vector of filter error and step size product.
// scaleFactorCoef Fixed scale factor for filter coefficients (0 < scaleFactor < 32).
//
// Returns:
// ippStsNoErr No Error.
// ippStsNullPtrErr pSrcStepSize, ppSrcFilterInput, pSrcError or ppSrcDstCoefsQ15 is null.
// ippStsLengthErr len is out of range.
// ippStsRangeErr numSegments or scaleFactorCoef is out of range.
// ippStsSizeErr pSrcStepSize[indexVec].val is out of range.
//
*/
IPPAPI(IppStatus, ippsFIRSubbandCoeffUpdate_EC_32fc_I, (
const double *pSrcStepSize,
const Ipp32fc **ppSrcFilterInput,
const Ipp32fc *pSrcError,
Ipp32fc **ppSrcDstCoefs,
int numSegments,
int len))
IPPAPI(IppStatus, ippsFIRSubbandAPCoeffUpdate_EC_32fc_I, (
const Ipp64f** ppSrcStepSize,
const Ipp32fc** ppSrcFilterInput,
const Ipp32fc** ppSrcError,
Ipp32fc** ppSrcDstCoefs,
Ipp32u numSegments,
Ipp32u len,
Ipp32u apOrder))
IPPAPI(IppStatus, ippsFIRSubbandCoeffUpdate_EC_32sc_I, (
const Ipp32s_EC_Sfs *pSrcStepSize,
const Ipp32sc **ppSrcFilterInput,
const Ipp32sc *pSrcError,
Ipp32sc **ppSrcDstCoefsQ15,
int numSegments,
int len,
int scaleFactorCoef))
IPPAPI(IppStatus, ippsFIRSubbandLowCoeffUpdate_EC_32sc_I, (
const Ipp32sc** ppSrcFilterInput,
const Ipp32sc* pSrcError,
Ipp32sc** ppSrcDstCoefsQ15,
int numSegments,
Ipp32sc* pDstProdStepErrQ,
const Ipp32s_EC_Sfs* pSrcAdaptStepSize,
int startSubband,
int numSubbands,
int scaleFactorCoef))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsToneDetectGetStateSize_EC
//
// Purpose:
// Returns size of the state structure
//
// Parameters:
// sampleFreq Sample frequency.
// pSize Pointer to the computed buffer size value
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified
// pointers is NULL.
// ippStsRangeErr Indicates an error when sampleFreq is not a valid element
// of the enumerated type IppPCMFrequency.
// ippStsRangeErr Indicates an error when sampleFreq is not a
// valid element of the enumerated type IppFrequency
//
*/
IPPAPI(IppStatus, ippsToneDetectGetStateSize_EC_32f, (IppPCMFrequency sampleFreq, int *pSize))
IPPAPI(IppStatus, ippsToneDetectGetStateSize_EC_16s, (IppPCMFrequency sampleFreq, int *pSize))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsToneDetectInit_EC
//
// Purpose:
// Initializes the state structure
//
// Parameters:
// pState Pointer to the memory buffer to be initialized
// as the tone detector state structure. The size
// of memory to be acquired by the
// ippsToneDetectGetStateSize_EC function via pSize
// parameter.
// sampleFreq Sample frequency
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsRangeErr Indicates an error when sampleFreq is not a valid element
// of the enumerated type IppPCMFrequency.
// ippStsRangeErr Indicates an error when sampleFreq is not a
// valid element of the enumerated type IppFrequency
*/
IPPAPI(IppStatus, ippsToneDetectInit_EC_32f, (IppsToneDetectState_EC_32f *pState,
IppPCMFrequency sampleFreq))
IPPAPI(IppStatus, ippsToneDetectInit_EC_16s, (IppsToneDetectState_EC_16s *pState,
IppPCMFrequency sampleFreq))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsToneDetect_EC
//
// Purpose:
// Detects signal 2100 Hz with every 450 ms phase reversal
//
// Parameters:
// pSignal Pointer to signal vector.
// len Number of samples in signal vector
// pResult Pointer to result value (not zero means tone was
// detected)
// pState Pointer to the tone detector state structure.
//
// Returns:
// ippStsNoErr Indicates no error.
*/
IPPAPI(IppStatus, ippsToneDetect_EC_32f, (const Ipp32f *pSignal,
int len, int *pResult,
IppsToneDetectState_EC_32f *pState))
IPPAPI(IppStatus, ippsToneDetect_EC_16s, (const Ipp16s *pSignal,
int len, int *pResult,
IppsToneDetectState_EC_16s *pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandControllerDT_EC_16s
//
// Purpose:
// Main controller function. Updates coefficients of filters. Returns
// output gain coefficients
//
// Parameters:
// pSrcAdaptiveFilterErr Pointer to the adaptive filter error vector of
// length equal to numSubbands, specified in
// ippsSubbandControllerInit_EC function
// pSrcFixedFilterErr Pointer to errors of fixed filter. Length is
// equal to numSubbands
// ppDstAdaptiveCoefs Pointer to an array of pointers to the filter
// Length of array coefficients vectors =
// numSegments, specified in
// ippsSubbandControllerInit_EC
// ppDstFixedCoefs Pointer to an array of pointers to the filter
// Length of array coefficients vectors =
// numSegments, specified in
// ippsSubbandControllerInit_EC
// pSrcDstFilterPwr Pointer to an input/output power of adaptive filter coefficient.
// pDstStsAdapt Pointer to output flag which shows controller state.
// *pDstStsAdapt = -1 - coefficients of adaptive filter have been copied to the fixed filter.
// *pDstStsAdapt = 0 - nothing happened.
// *pDstStsAdapt = 1 - coefficients of fixed filter have been copied to the adaptive filter.
// pwrDelta Adaptive filter coefficients power change value (adaptive filter coefficients power
// of the current frame minus adaptive filter coefficients power of the previous frame).
// filterUpdateEnabled Indicator which indicates possibility to change (update) adaptive filter
// coefficients in this frame.
// adaptationEnabled Indicator which indicates if adaptation is enabled or not.
// startSubband Number of subbands to skip before filtering (0? startSubband < numSubbands).
// pState Pointer to SubbandControllerDT_EC state structure.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when one of the specified pointers is NULL.
// ippStsBadArgErr Indicates an error when startSubband is less 0 or startSubband is greater than or equal to numSubbands.
*/
IPPAPI(IppStatus, ippsSubbandControllerDT_EC_16s, (const Ipp32sc* pSrcAdaptiveFilterErr, const Ipp32sc* pSrcFixedFilterErr,
Ipp32sc** ppDstAdaptiveCoefs, Ipp32sc** ppDstFixedCoefs, Ipp64s* pSrcDstFilterPwr, int* pDstStsAdapt, Ipp64s pwrDelta,
int filterUpdateEnabled, int adaptationEnabled, int startSubband, IppsSubbandControllerDTState_EC_16s* pState))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippsSubbandControllerDTUpdate_EC
//
// Purpose:
// Updates controller state. Returns step sizes.
//
// Parameters:
// ppSrcRinSubbandsHistory Pointer to an array of pointers to the most
// recent receive-in blocks. Size of array is equal
// to numSegments, specified in
// ippsSubbandControllerInit_EC function
// pSrcSinSubbands Pointer to subband representation of send-in
// signal frame (or NULL). Size of array =
// numSubbands, specified in
// ippsSubbandControllerInit_EC function
// pSrcFilterErr Pointer to the input filter error vector. Vector length is equal to numSubbands
// specified in ippsSubbandControllerInit_EC function.
// pDstStepSize Pointer to step sizes. Length of vector =
// numSubbands, specified in
// ippsSubbandControllerInit_EC function
// pIsDT Pointer to the indicator which indicate double-talk condition.
// pDisabledNLP Pointer to the indicator which indicate whether NLP is disable (1) or not (0).
// startSubband Number of subbands to skip before filtering (0? startSubband < numSubbands).
// pState Pointer to SubbandControllerDT_EC state structure.
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when pState, pRin, pSin,
// pRinSubbands or pStepSize is NULL.
// ippStsBadArgErr Indicates an error when startSubband is less 0 or startSubband is greater than or equal to numSubbands.
*/
IPPAPI(IppStatus, ippsSubbandControllerDTUpdate_EC_16s, (const Ipp32sc** ppSrcRinSubbandsHistory,
const Ipp32sc* pSrcSinSubbands, const Ipp32sc* pSrcFilterErr, Ipp32s_EC_Sfs* pDstStepSize,
int* pIsDT, int* pDisabledNLP, int startSubband, IppsSubbandControllerDTState_EC_16s* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Echo Canceller end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// MSRTA related functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct _QMFState_MSRTA_32s IppsQMFState_MSRTA_32s;
typedef struct _QMFState_RTA_32f IppsQMFState_RTA_32f;
typedef struct _ShortTermPostFilterState_MSRTA_32s IppsShortTermPostFilterState_MSRTA_32s;
typedef struct _PostFilterState_RTA_32f IppsPostFilterState_RTA_32f;
#endif
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLPCToLSP_RTA
//
// Purpose: Converts a set of 10th-order LP coefficients to
// an equivalent set of line spectrum pairs (LSPs).
// Parameters:
// pSrcLPC Pointer to LP coefficient vector [order].
// pDstLSP Pointer to the LSP coefficient vector [order].
// order LP coefficient filter order.
// Returns: IppStatus
// ippStsNoRootFoundErr if number of roots less than order
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLPCToLSP_RTA_32f,(const Ipp32f* pSrcLPC, Ipp32f* pDstLSP, int order))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSPToLPC_RTA
//
// Purpose: Converts a set of order LSPs to LP coefficients.
// Parameters:
// pSrcLSP Pointer to the input LSFs [order].
// pDstLPC Pointer to the output predictive coefficients [order].
// order LP coefficient filter order.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLSPToLPC_RTA_32f,(const Ipp32f* pSrcLSP, Ipp32f* pDstLPC, int order))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLevinsonDurbin_RTA
// Purpose: Obtaining of the LPC using durbin algorithm
// Parameters:
// pSrcAutoCorr Pointer to the autocorrelation vector [order+1].
// pDstLPC Pointer to the LPC output vector [order+1].
// pDstRC Pointer to the RC output vector [order].
// order LP order.
//
*/
IPPAPI(IppStatus, ippsLevinsonDurbin_RTA_32f, (const Ipp32f* pSrcAutoCorr, Ipp32f* pDstLPC, Ipp32f* pDstRC, int order))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFGetStateSize_RTA
// Purpose: Knowing of MSRTA QMF filter size demand
// Parameters:
// pSize pointer to the output value of the memory size needed for QMF filter
// Returns:
// ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsQMFGetStateSize_RTA_32f, ( int* pSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFInit_RTA
// Purpose: Initialization of the memory allocated for QMF filter
// Parameters:
// pQMFMem Pointer to the memory supplied for filtering.
// nTaps Number of taps: 24, 48.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsQMFInit_RTA_32f,( IppsQMFState_RTA_32f* pQMFMem, int nTaps ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFDecode_RTA
// Purpose: QMF synthesis filter implementation
// Parameters:
// ptQmf QMF filter structure.
// pSrcLow Pointer to the input buffer low band (len).
// pSrcHigh Pointer to the input buffer high band (len).
// len Length of the input buffer size.
// pDst Pointer to the output buffer (2 * len).
// pQMFMem Pointer to the memory supplied for filtering.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsQMFDecode_RTA_32f,(const Ipp32f* pSrcLow, const Ipp32f* pSrcHigh,
int len, Ipp32f* pDst, IppsQMFState_RTA_32f* pQMFMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFEncode_RTA
// Purpose: QMF analysis filter implementation
// Parameters:
// pSrc Pointer to the input buffer (len).
// len Length of the input buffer size.
// pDstLow Pointer to the output buffer low band (len / 2).
// pDstHigh Pointer to the output buffer high band (len / 2).
// pQMFMem Pointer to the memory supplied for filtering.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI(IppStatus, ippsQMFEncode_RTA_32f,(const Ipp32f* pSrc, int len, Ipp32f* pDstLow,
Ipp32f* pDstHigh, IppsQMFState_RTA_32f* pQMFMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilterGetStateSize_RTA
// Purpose: Knowing of MSRTA Short Term Post filter size demand
// Parameters:
// pSize pointer to the output value of the memory size needed for STP filter
// Returns:
// ippStsNoErr, if no errors
*/
IPPAPI(IppStatus ,ippsPostFilterGetStateSize_RTA_32f,(int* pSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilterInit_RTA
// Purpose: Initialization of the memory allocated for STP filter
// Parameters:
// pStateMem Pointer to the memory supplied for filtering.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus ,ippsPostFilterInit_RTA_32f,( IppsPostFilterState_RTA_32f *pStateMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPostFilter_RTA
// Purpose: Adaptive Short-term Post Filter (APF)
// pSrcLPC pointer to the LPC coefficients.
// order LPC Order.
// pSrcDstSpeech pointer to the input/output speech buffer.
// len Length of input speech.
// apfIdx Index for different parameter value.
// harmonic and full band coding: iApfIdx = 0
// subband coding: iApfIdx = 1,3,4 respectively
// streaming coding: iApfIdx = 2,5,6 respectively
// pMem Pointer to the apf memory [33].
// pStateMem Pointer to the apf state memory.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus ,ippsPostFilter_RTA_32f_I,(const Ipp32f* pSrcLPC, int order, Ipp32f* pSrcDstSpeech,
int len, int pfType, Ipp32f* pMem,
IppsPostFilterState_RTA_32f* pStateMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAdaptiveCodebookSearch_RTA
// Purpose: Adaptive Codebook Search
// pSrcAdptTarget Pointer to the input target signal (subFrameSize).
// pSrcImpulseResponse Pointer to the input impulse response (subFrameSize).
// subFrameSize Subframe size.
// pSrcBoundary Pointer to the input acb search boundaries (4).
// pSrcDstExc Pointer to the input/output current excitation buffer.
// pSrcDstLag Pointer to the input / output the lag.
// pDstAdptIndex Pointer to the output acb index.
// pDstAdptContribution Pointer to the output acb contribution (subFrameSize).
// deltaSearchRange Delta search range value.
// searchFlag 0 - full search, 1 - search around open-loop pitch.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsAdaptiveCodebookSearch_RTA_32f,(
const Ipp32f* pSrcAdptTarget, const Ipp32f* pSrcImpulseResponse, int subFrameSize, const Ipp32f* pSrcBoundary,
Ipp32f* pSrcDstExc, Ipp32f* pSrcDstLag, int* pDstAdptIndex,
Ipp32f* pDstAdptContribution, int deltaSearchRange, int searchFlag))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFixedCodebookSearch_RTA
// Name: ippsFixedCodebookSearchRandom_RTA
// Purpose: Two tracks Fixed Codebook Search
// pSrcFixedTarget Pointer to the input target signal.
// pSrcImpulseResponse Pointer to the input impluse response.
// pDstFixedVector Pointer to the output FCB vector.
// subFrameSize Subframe size.
// pDstFixedIndex Pointer to the output codeword index.
// pDstGain Pointer to the output optimal gain.
// numPulses Number of pulses.
// complexity Complexity control parameter.
// codebookSize Random codebook size (64, 160, 256).
// nStage Stage number (0, 1,2).
// gainLimit Gain constrain limit flag(1, 2, 3, 4).
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsFixedCodebookSearch_RTA_32f,(
const Ipp32f* pSrcFixedTarget, const Ipp32f* pSrcImpulseResponse, Ipp32f* pDstFixedVector,
int subFrameSize, int* pDstFixedIndex, Ipp32f* pDstGain, int numPulses, int complexity))
IPPAPI(IppStatus, ippsFixedCodebookSearchRandom_RTA_32f,(
const Ipp32f * pSrcResidualTarget, const Ipp32f * pSrcImpulseResponse, Ipp32f *pDstFixedVector,
int subFrameSize, int* pDstFixedIndex, Ipp32f *pDstGain, int codebookSize,
int nStage, int gainLimit))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSPQuant_RTA
// Purpose: Quantize LSP parameters
// pSrcLSP Pointer to the input unquantized LSP vector.
// pSrcLPC Pointer to the input unquantized LPC vector.
// pDstLSP Pointer to the output quantized LSP vector.
// order LP coefficient filter order.
// pDstLSPIndex Pointer to the vector of quantized LSP indices.
// numMSVQStages Number stages MSVQ for LSP.
// frequency Sampling frequency.
// complexity Complexity control parameter.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsLSPQuant_RTA_32f,(
const Ipp32f* pSrcLSP, const Ipp32f* pSrcLPC, Ipp32f* pDstLSP, int order,
int* pDstLSPIndex, IppPCMFrequency frequency, int complexity))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHighPassFilter_RTA_
// Purpose: High pass filtering with lattice structure
// pSrc Pointer to the input buffer.
// pDst Pointer to the output buffer.
// len Length of input /output buffers.
// hpfOrder Filter order 4 or 5.
// frequency Sampling frequency.
// pMem Pointer to the filter memory.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsHighPassFilter_RTA_32f,(const Ipp32f* pSrc, Ipp32f* pDst, int len, int hpfOrder, IppPCMFrequency frequency, Ipp32f* pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsBandPassFilter_RTA
// Purpose: Performs band pass filter
// pSrcDst Pointer to the input/output speech vector [len].
// len Number of elements in the pSrcDst vector.
// pMem Pointer to the memory allocated for the frequency enhancement filter [len+2].
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI(IppStatus, ippsBandPassFilter_RTA_32f_I,(Ipp32f* pSrcDst, int len, Ipp32f *pMem))
/* /////////////////////////////////////////////////////////////////////////////
// MSRTA end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// G7291 related functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct _FilterHighpassState_G7291_16s IppsFilterHighpassState_G7291_16s;
typedef struct _QMFState_G7291_16s IppsQMFState_G7291_16s;
typedef struct _GenerateExcitationState_G7291_16s IppsGenerateExcitationState_G7291_16s;
#endif
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterHighpassGetStateSize_G7291_16s
// Purpose: Knowing of G7291 high-pass filter size demand
// Parameters:
// pSize Pointer to the output value of the memory size.
// Returns:
// ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsFilterHighpassGetStateSize_G7291_16s, (int* pSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterHighpassInit_G7291_16s
// Purpose: Initialization of the memory allocated for preprocessing filter
// Parameters:
// pState Pointer to memory supplied for filtering.
// pCoeff Pointer to the source vector of the filter coefficients.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsFilterHighpassInit_G7291_16s, (IppsFilterHighpassState_G7291_16s* pState,
const Ipp16s* pCoeff))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterHighpass_G7291_16s_ISfs
// Purpose: The input sampled speech shall be high-pass filtered
// Parameters:
// pSrcDst Pointer to the source and destination vector (for in-place operation).
// len Length of the pSrcDst.
// pState Pointer to the memory supplied for filtering.
// scaleFactor Scaling factor to apply to the result.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsFilterHighpass_G7291_16s_ISfs, (Ipp16s* pSrcDst, int len,
IppsFilterHighpassState_G7291_16s* pState, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterLowpass_G7291_16s_I
// Purpose: The input sampled speech shall be low-pass filtered
// Parameters:
// pSrcDst Pointer to the source and destination vector (for in-place operation).
// len Length of the pSrcDst.
// pMem Pointer to the memory supplied for filtering.
// hint Code specific use hints.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsFilterLowpass_G7291_16s_I, (Ipp16s* pSrcDst, int len, Ipp16s* pMem,
IppHintAlgorithm hint))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFGetStateSize_G7291_16s
// Purpose: Knowing of G7291 QMF analysis filter size demand
// Parameters:
// pSize Pointer to the output value of the memory size.
// Returns:
// ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsQMFGetStateSize_G7291_16s, (int* pSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFInit_G7291_16s
// Purpose: Initialization of the memory allocated for QMF filter
// Parameters:
// pState Pointer to the memory supplied for QMF encode.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsQMFInit_G7291_16s, (IppsQMFState_G7291_16s* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFEncode_G7291_16s
// Purpose: Two-channel filter bank analysis.
// Parameters:
// pSrc Pointer to the input vector [len].
// len Number of samples.
// pDstLowBand Pointer to the output lower-band vector [[len/2].
// pDstHighBand Pointer to the output higher-band vector [len/2].
// pState Pointer to the memory supplied for QMF encode.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsQMFEncode_G7291_16s, (const Ipp16s* pSrc, int len,
Ipp16s* pDstLowBand, Ipp16s* pDstHighBand, IppsQMFState_G7291_16s* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQMFDecode_G7291_16s
// Purpose: Two-channel filter bank synthesis.
// Parameters:
// pSrcLowBand Pointer to the input lower-band vector [len].
// pSrcHighBand Pointer to the input higher-band vector [len].
// valGainSwitching Gain attenuation factor.
// len Number of samples.
// pDst Pointer to the output vector [len*2].
// pState Pointer to the memory supplied for QMF decode.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsQMFDecode_G7291_16s, (const Ipp16s* pSrcLowBand, const Ipp16s* pSrcHighBand,
Ipp16s valGainSwitching, int len, Ipp16s* pDst, IppsQMFState_G7291_16s* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLSFDecode_G7291_16s
// Purpose: Construct LSFs by codebook indices
// Parameters:
// pQuantIndex Pointer to the input vector of codebook indices.
// pSrcDstPrevLSF Pointer to the input/output table of 4 previously quantized LSFs vectors.
// pSrcDstLSF Pointer to the quantized LSF input/output vector.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsLSFDecode_G7291_16s, (const Ipp16s* pQuantIndex, Ipp16s* pSrcDstPrevLSF,
Ipp16s* pSrcDstLSF))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsAdaptiveCodebookSearch_G7291_16s
// Purpose: Determination of optimal integer and fractional pitch delay
// and generation of adaptive codebook vector
// Parameters:
// pSrcAdptTarget Pointer to the target signal for adaptive-codebook search vector [40].
// pSrcImpulseResponse Pointer to the impulse response of weighted synthesis filter vector [40]
// pSrcPrevExcitation Pointer to the previous and updated excitation vector [154].
// pDstDelay Pointer to the integer delay and fraction delay vector [2].
// lagMin Minimum value in the searched range.
// lagMax Maximum value in the searched range.
// subFrame Subframe number, either 0 or 1.
*/
IPPAPI (IppStatus, ippsAdaptiveCodebookSearch_G7291_16s, (const Ipp16s* pSrcAdptTarget,
const Ipp16s* pSrcImpulseResponse, const Ipp16s* pSrcPrevExcitation, Ipp16s* pDstDelay,
Ipp16s lagMin, Ipp16s lagMax, int subFrame))
/* /////////////////////////////////////////////////////////////////////////////
// Name : ippsAdaptiveCodebookGain_G7291_16s
// Purpose: Compute the adaptive codebook gain
//
// pSrcAdptTarget Pointer to the adaptive target signal vector [40].
// pSrcImpulseResponse Pointer to the impulse response of the perceptual weighting filter vector [40].
// pSrcAdptVector Pointer to the adaptive-codebook vector [40].
// pDstFltAdptVector Pointer to the output filtered adaptive-codebook vector [40].
// pResultAdptGain Pointer to the adaptive-codebook gain in the length of 1, in Q14.
*/
IPPAPI (IppStatus, ippsAdaptiveCodebookGain_G7291_16s, (const Ipp16s* pSrcAdptTarget,
const Ipp16s* pSrcImpulseResponse, const Ipp16s* pSrcAdptVector, Ipp16s* pDstFltAdptVector,
Ipp16s* pResultAdptGain))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAlgebraicCodebookSearch
// Purpose: Fixed (algebraic) codebook search function (1st Layer)
// Parameters:
// pSrcFixedTarget Pointer to the input updated target speech vector [40].
// pSrcLtpResidual Pointer to the input residual after long term prediction vector [40].
// pSrcDstFltAdptVector Pointer to the output filtered adaptive fixed-codebook vector [40].
// pSrcDstImpulseResponse Pointer to the output LP synthesis filter [40].
// pitchLag Pitch lag value.
// pitchGain Last quantized pitch gain value.
// pDstFixedVector Pointer to the fixed-codebook vector [40].
// pDstFltFixedVector Pointer to the output filtered fixed-codebook vector [40].
// pDstCodebookIdx Pointer to the fixed-codebook index [2].
// voiceFactor Voicing factor value.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsAlgebraicCodebookSearchL1_G7291_16s, (const Ipp16s* pSrcFixedTarget,
const Ipp16s* pSrcLtpResidual, Ipp16s* pSrcDstFltAdptVector, Ipp16s* pSrcDstImpulseResponse,
Ipp16s pitchLag, Ipp16s pitchGain, Ipp16s* pDstFixedVector, Ipp16s* pDstFltFixedVector,
Ipp16s* pDstCodebookIdx))
IPPAPI (IppStatus, ippsAlgebraicCodebookSearchL2_G7291_16s, (const Ipp16s* pSrcFixedTarget,
const Ipp16s* pSrcLtpResidual, const Ipp16s* pSrcImpulseResponse, Ipp16s voiceFactor,
Ipp16s* pDstFixedVector, Ipp16s* pDstFltFixedVector, Ipp16s* pDstCodebookIdx))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainQuant_G7291_16s
// Purpose: Quantization of the adaptive codebook gains of 2nd stage
// Parameters:
// pSrcFixedTarget Pointer to the target signal for adaptive codebook search vector [40].
// pSrcFltFixedVector Pointer to the filtered fixed codebook vector [40].
// valSrcQGain Quantized gain of 1st stage.
// pDstQGainIndex Pointer to the output gain codebook index.
// pDstQGain Pointer to the output quantized gain.
// subFrame Subframe number in range [0,3].
//
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsGainQuant_G7291_16s, (const Ipp16s* pSrcFixedTarget, const Ipp16s* pSrcFltFixedVector,
Ipp16s valSrcQGain, Ipp16s* pDstQGainIndex, Ipp16s* pDstQGain, int subFrame))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEnvelopTime_G7291_16s
// Purpose: TDBWE time envelope (segment energy) computation
// Parameters:
// pSrc Pointer to the original highband input signal [10*subFrame].
// nls Normalization of the input signal.
// pDstEnvelopTime Pointer to the output time envelope parameters [subFrame].
// subFrame Number of consecutive subframes in pSrc.
//
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsEnvelopTime_G7291_16s, (const Ipp16s* pSrc, Ipp16s nls,
Ipp16s* pDstEnvelopTime, int subFrame))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsEnvelopFrequency_G7291_16s
// Purpose: TDBWE frequency envelope (sub-band energy) computation
// Parameters:
// pSrc Pointer to the original highband input signal [64].
// pDstEnvelopFreq Pointer to the output frequency envelope parameters [12].
//
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsEnvelopFrequency_G7291_16s, (const Ipp16s* pSrc, Ipp16s* pDstEnvelopFreq))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGenerateExcitationGetStateSize_G7291_16s
// Purpose: Knowing of TDBWE generate excitation size demand
// Parameters:
// pSize Pointer to the output value of the memory size.
// Returns:
// ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsGenerateExcitationGetStateSize_G7291_16s, (int* pSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGenerateExcitationInit_G7291_16s
// Purpose: Initialization of the memory allocated for generate excitation
// Parameters:
// pState Pointer to the memory supplied for generation of the excitation signal.
// Returns: ippStsNoErr, if no errors
*/
IPPAPI (IppStatus, ippsGenerateExcitationInit_G7291_16s, (IppsGenerateExcitationState_G7291_16s* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGenerateExcitation_G7291_16s
// Purpose: TDBWE excitation generator: produce pitch-synchronous excitation
// signal based on G.729 parameters
// Parameters:
// pIntPitchLag Pointer to the integer part of pitch lag.
// pFracPitchLag Pointer to the fractional part of pitch lag.
// pLtpPower Pointer to the ltp power ratio.
// pFixPower Pointer to the fix power ratio.
// pState Pointer to the memory supplied for generate excitation.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsGenerateExcitation_G7291_16s, (const Ipp16s* pIntPitchLag,
const Ipp16s* pFracPitchLag, const Ipp32s* pLtpPower, const Ipp32s* pFixPower,
Ipp16s* pDst, IppsGenerateExcitationState_G7291_16s* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsShapeEnvelopTime_G7291_16s
// Purpose: TDBWE time envelope shaping module,
// shape time envelope of pSrc according to pSrcTimeEnvelope
// Parameters:
// pSrc Pointer to the excitation input signal [80].
// pSrcEnvelopTime Pointer to the desired time envelope [8].
// pSrcDstGain Pointer to the gain of the time envelope shaping.
// pSrcDstNorm Pointer to the norm of the time envelope shaping.
// pDst Pointer to the shaped output signal [208].
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsShapeEnvelopTime_G7291_16s, (const Ipp16s* pSrc,
const Ipp16s* pSrcEnvelopTime, Ipp16s* pSrcDstGain, Ipp16s* pSrcDstNorm,
Ipp16s* pDst))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsShapeEnvelopFrequency_G7291_16s
// Purpose: TDBWE frequency envelope shaping module
// shape frequency envelope of pSrc according to pSrcFreqEnvelope
// Parameters:
// pSrc Pointer to the input signal [208].
// pSrcEnvelopFreq Pointer to the desired frequency envelope [12].
// pDst Pointer to the shaped output signal [80].
// pDstFilterCoeffs Pointer to the filtering coefficients for frequency envelope shaping [33].
// pMem Pointer to the memory supplied for frequency envelope shaping [32].
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsShapeEnvelopFrequency_G7291_16s, (const Ipp16s* pSrc,
const Ipp16s* pSrcEnvelopFreq, Ipp16s* pDst, Ipp16s* pDstFilterCoeffs, Ipp16s* pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCompressEnvelopTime_G7291_16s
// Purpose: Postprocessing of the TDBWE output by adaptive amplitude compression
// Parameters:
// pSrcEnvelopTime Pointer to the desired time envelope [28].
// pSrcDst Pointer to the shaped input/output signal [160].
// pMem Pointer to the memory for 2 past time envelope parameters.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsCompressEnvelopTime_G7291_16s, (const Ipp16s* pSrcEnvelopTime,
Ipp16s* pSrcDst, Ipp16s* pMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMDCTFwd_G7291_16s
// Purpose: Compute MDCT
// Parameters:
// pSrc Pointer to the input signal [160].
// pSrcDst Pointer to the previous input signal [160].
// pDstNorm Pointer to the output normalization factor.
// pDstMDCTCoeffs Pointer to the output MDCT coefficients [160].
// hint Suggests using specific code.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsMDCTFwd_G7291_16s, (const Ipp16s* pSrc, const Ipp16s* pSrcPrev,
int* pDstNorm, Ipp16s* pDstMDCTCoeffs, IppHintAlgorithm hint ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMDCTInv_G7291_16s
// Purpose: Compute inverse MDCT
// Parameters:
// pMDCTCoeffs Pointer to the MDCT coefficients [160].
// pSrcDstMDCTPrevCoeffs Pointer to the old input/output MDCT memory [160].
// pDst Pointer to the output signal [160].
// scaleFactor Scale factor for the normalization MDCT coefficients.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsMDCTInv_G7291_16s, (const Ipp16s* pMDCTCoeffs,
Ipp16s* pSrcDstMDCTPrevCoeffs, Ipp16s* pDst, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMDCTQuantFwd_G7291_16s32u
// Purpose: Split spherical vector quantization.
// Parameters:
// pMDCTCoeffs Pointer to the input MDCT coefficients [320].
// pBitsNumber Pointer to the input number of bits allocated per subbands [18].
// pDst Pointer to the output vector quantization [18].
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsMDCTQuantFwd_G7291_16s32u,
(const Ipp16s* pMDCTCoeffs, const Ipp16s* pBitsNumber, Ipp32u* pDst))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMDCTQuantDecode_G7291_32u16s
// Purpose: Inverse split spherical vector quantization.
// Parameters:
// pSrc Pointer to the input vector quantization indices [18].
// pBitsNumber Pointer to the input number of bits allocated per subbands [18].
// pQuantSpecEnv Pointer to the input quantized spectrum envelope [18].
// pMDCTCoeffs Pointer to the output MDCT coefficients [320].
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsMDCTQuantInv_G7291_32u16s,
(const Ipp32u* pSrc, const Ipp16s* pBitsNumber,
const Ipp16s* pQuantSpecEnv, Ipp16s* pDstMDCTCoeffs))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMDCTPostProcess_G7291_16s
// Purpose: Post-processing of higher-band MDCT coefficients.
// Parameters:
// pSrcDstMDCTCoeffs Pointer to the input/output MDCT coefficients [160].
// numBits Number of bits to decode in TDAC.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI (IppStatus, ippsMDCTPostProcess_G7291_16s, (Ipp16s* pSrcDstMDCTCoeffs,
int numBits))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGainControl_G7291_16s_I
// Purpose: Adaptive gain control
// Compensate for the gain difference between reconstructed speech signal given
// pSrc (sr) and the postfiltered signal given by pSrcDst (spf)
// dst[i] = g[i] * dst[i]
// pSrc Pointer to the source reconstructed speech vector [40].
// pSrcDst Pointer to the input post-filtered signal and output
// gain-compensated signal vector [40].
// pSrcDstGain Pointer to the gain for the previous subframe.
// gain First reflection coefficient.
// valGainSwitching Gain attenuation factor.
// pSrcDstSmoothLevel Pointer to the input/output smooth level.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsGainControl_G7291_16s_I, (const Ipp16s* pSrc, Ipp16s *pSrcDst,
Ipp16s* pSrcDstGain, Ipp16s gain, Ipp16s valGainSwitching,
Ipp32s* pSrcDstSmoothLevel))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsTiltCompensation_G7291_16s
// Purpose: Tilt compensation filter
// transfer function 1/(1-|mu|) * (1 + mu * 1/z)
// pSrc Pointer to the gamma weighted LP coefficients input vector [40].
// pDst Pointer to the present and tilt-compensated output speech [40].
// gain Gain coefficient.
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsTiltCompensation_G7291_16s, (const Ipp16s* pSrc, Ipp16s* pDst,
Ipp16s gain))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsQuantParam_G7291_16s
// Purpose: Quantization of the TDBWE parameter set by "mean removed VQ"
//
// Parameters:
// pSrcDst Pointer to the source/destination unquantized parameter set [28].
// pCdbkIndices Pointer to the codebook indices [4].
// Returns: IppStatus
// ippStsNoErr if no error
*/
IPPAPI (IppStatus, ippsQuantParam_G7291_16s, (Ipp16s *pSrcDst, Ipp16s *pCdbkIndices))
/* /////////////////////////////////////////////////////////////////////////////
// G7291 end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Noise filters functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct _FilterNoiseState_RTA_32f IppsFilterNoiseState_RTA_32f;
typedef struct _FilterNoiseState_EC_32f IppsFilterNoiseState_EC_32f;
#endif
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterNoiseGetStateSize_*
// Purpose: Knowing of RTA Noise Suppression size demand
// Parameters:
// pcmFreq Sampling frequency.
// pSize Pointer to the output value of the memory size.
// Returns:
// ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsFilterNoiseGetStateSize_RTA_32f, (IppPCMFrequency pcmFreq, int* pSize ))
IPPAPI(IppStatus, ippsFilterNoiseGetStateSize_EC_32f, (IppPCMFrequency pcmFreq,int *size))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterNoiseInit_*
// Purpose: Initialization of the memory allocated for Noise Suppression Main Algorithm
// Parameters:
// pcmFreq Sampling frequency.
// pNRStateMem Pointer to the memory supplied for filter state.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsFilterNoiseInit_RTA_32f, (IppPCMFrequency pcmFreq, IppsFilterNoiseState_RTA_32f* pNRStateMem))
IPPAPI(IppStatus, ippsFilterNoiseInit_EC_32f, (IppPCMFrequency pcmFreq, IppsFilterNoiseState_EC_32f* pNRStateMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterNoiseLevel_*
// Purpose: Set the level of noise attenuation
// Parameters:
// level The enumerated value which defines the degree of noise attenuation.
// pNRStateMem Pointer to the memory supplied for Noise Suppression.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsFilterNoiseLevel_RTA_32f, (IppsNRLevel level, IppsFilterNoiseState_RTA_32f* pNRStateMem))
IPPAPI(IppStatus, ippsFilterNoiseLevel_EC_32f, (IppsNRLevel level, IppsFilterNoiseState_EC_32f* pNRStateMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterNoiseSetMode_EC_32f
// Purpose: Set the type of smoothing algorithm applied
// Parameters:
// mode The enumerated value which defines the smoothing mode
// pNRStateMem Pointer to the memory supplied for Noise Suppression.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsFilterNoiseSetMode_EC_32f, (IppsNrSmoothMode mode, IppsFilterNoiseState_EC_32f* pNRStateMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: _ippsFilterNoiseDetect_EC_32f64f
// Purpose: Performs Noise Suppression Main Algorithm
// Parameters:
// pSrc1 Pointer to the "sin" input vector.
// pSrc2 Pointer to the "rin" input vector.
// pNoisePwr Pointer to the noise detected power.
// pMean Weighted mean of the noise.
// pDstFlag 1-noise detected, 0-not detected
// pNRStateMem Pointer to the memory supplied for Noise Suppression.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsFilterNoiseDetect_EC_32f64f, (const Ipp32f pSrc1[16],Ipp64f *pNoisePwr,
Ipp32f *pMean,int *pDstFlag,IppsFilterNoiseState_EC_32f *pNRStateMem))
IPPAPI(IppStatus, ippsFilterNoiseDetectModerate_EC_32f64f, (const Ipp32f pSrc1[16],const Ipp32f pSrc2[16],Ipp64f *pNoisePwr,
Ipp32f *pMean,int *pDstFlag,IppsFilterNoiseState_EC_32f *pNRStateMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFilterNoise_*
// Purpose: Performs Noise Suppression Main Algorithm
// Parameters:
// pSrc Pointer to the input vector.
// pDst Pointer to the output vector.
// pSrcDst Pointer to the input/output vector.
// noiseFlag Enumerated value defines filter state update.
// pNRStateMem Pointer to the memory supplied for Noise Suppression.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsFilterNoise_RTA_32f, (const Ipp32f pSrc[160], Ipp32f pDst[160], IppsFilterNoiseState_RTA_32f* pNRStateMem ))
IPPAPI(IppStatus, ippsFilterNoise_RTA_32f_I, (Ipp32f pSrcDst[160], IppsFilterNoiseState_RTA_32f* pNRStateMem ))
IPPAPI(IppStatus, ippsFilterNoise_EC_32f, (const Ipp32f pSrc[16],Ipp32f pDst[16],IppsNrMode noiseFlag,
IppsFilterNoiseState_EC_32f *pNRStateMem))
IPPAPI(IppStatus, ippsFilterNoise_EC_32f_I, (Ipp32f pSrcDst[16],IppsNrMode noiseFlag,IppsFilterNoiseState_EC_32f *pNRStateMem))
/* /////////////////////////////////////////////////////////////////////////////
// Noise filters end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// ALC functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct _ALCState_G169_16s IppsALCState_G169_16s;
#endif
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsALCGetStateSize_G169_16s
// Purpose: Knowing of Speech level control size demand
// Parameters:
// pSize Pointer to the output value of the memory size needed for Speech Level Control
// Returns:
// ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsALCGetStateSize_G169_16s,(int* pSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsALCInit_G169_16s
// Purpose: Initialization of the memory allocated for Speech Level Control Algorithm
// Parameters:
// pALCMem Pointer to the memory supplied for Speech Level Control.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsALCInit_G169_16s,(IppsALCState_G169_16s* pALCMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsALCSetLevel_G169_16s
// Purpose: Set clip limit for the Speech Level Control
// Parameters:
// targetLevel Target level in dB.
// clipLevel Clip limit in dB.
// pALCMem Pointer to the memory supplied for Speech Level Control.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsALCSetLevel_G169_16s,(Ipp32f targetLevel, Ipp32f clipLevel, IppsALCState_G169_16s* pALCMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsALCSetGain_G169_16s
// Purpose: Set max gain limit for the Speech Level Control
// Parameters:
// targetLevel Max gain in dB.
// pALCMem Pointer to the memory supplied for Speech Level Control.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsALCSetGain_G169_16s,(Ipp32f maxGain, IppsALCState_G169_16s* pALCMem))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsALC_G169_16s
// Purpose: Speech Level Control
// Parameters:
// pSrc Pointer to the input vector.
// pDst Pointer to the output vector.
// pALCMem Pointer to the memory supplied for Speech Level Control.
// Returns: ippStsNoErr, if no errors
//
*/
IPPAPI(IppStatus, ippsALC_G169_16s,(const Ipp16s *pSrc, Ipp16s *pDst, int len, IppsALCState_G169_16s* pALCMem))
/* /////////////////////////////////////////////////////////////////////////////
// ALC functions end
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// G.728J related functions
///////////////////////////////////////////////////////////////////////////// */
/* ///////////////////////////////////////////////////////////////////////////
// Name: ippsCodebookSearchTCQ_G728_16s8u
//
// Purpose: This function performs codebook search by Trellis-Coded Quantization
// algorthm described in ITU G728 Annex J claus J.4.1.1 and stores trellis
// survivor path index in pBestNode and best path indices in pDst
//
// Parameters:
// pSrc Pointer to the input speech vector
// pSrcLPC Pointer to the LPC coefficients vector
// pDst Pointers to the output best path indices
// pSrcDstWindow Pointer to the synthesis filter hybrid window memory
// pSrcDstResidual Pointer to the input/outpu quantized residual vector
// pSrcDstBestNode Pointer to input/output survivor node value in Viterbi search
// invGain Inverted gain scaled value structure
// excGain Linear excitation gain scaled value structure
//
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when the pSrc, pSrcLPC, pSrcWindow,
// pSrcDstResidual, pSrcDstBestNode or pDst pointer is NULL.
//
*/
IPPAPI(IppStatus, ippsCodebookSearchTCQ_G728_16s8u,(const Ipp16s *pSrc, const Ipp16s *pSrcLPC,Ipp8u *pDst,
Ipp16s *pSrcDstWindow, Ipp16s *pSrcDstResidual, Ipp32s *pSrcDstBestNode,
Ipp32s_EC_Sfs invGain, Ipp32s_EC_Sfs excGain ))
/* /////////////////////////////////////////////////////////////////////////////
// G.728J end
///////////////////////////////////////////////////////////////////////////// */
#ifdef __cplusplus
}
#endif
#if defined (_IPP_STDCALL_CDECL)
#undef _IPP_STDCALL_CDECL
#define __stdcall __cdecl
#endif
#endif /* __IPPSC_H__ */
/* ////////////////////////////// End of file /////////////////////////////// */
Reference in New Issue Copy Permalink