📄 encamrwb.c
字号:
ippsEncDTXHandler_GSMAMR_16s(&st->dtxEncState.siHangoverCount,
&st->dtxEncState.siAnaElapsedCount, &dtxMode, &foo, valVadFlag);
if(dtxMode==IPP_SPCHBR_DTX) {
*rate = AMRWB_RATE_DTX;
irate = IPP_SPCHBR_DTX;
}
}
if (*rate != AMRWB_RATE_DTX)
{
*(pPrm)++ = valVadFlag;
}
/* Perform LPC analysis */
ownAutoCorr_AMRWB_16s32s(pWindow, LP_ORDER, pAutoCorrvec);
ownLagWindow_AMRWB_32s_I(pAutoCorrvec);
if(ippsLevinsonDurbin_G729_32s16s(pAutoCorrvec, LP_ORDER, pLPCUnQuantvec, pRCvec, &tmp) == ippStsOverflow){
pLPCUnQuantvec[0] = 4096;
ippsCopy_16s(st->asiLevinsonMem, &pLPCUnQuantvec[1], LP_ORDER);
pRCvec[0] = st->asiLevinsonMem[LP_ORDER]; /* only two pRCvec coefficients are needed */
pRCvec[1] = st->asiLevinsonMem[LP_ORDER+1];
}else{
ippsCopy_16s(pLPCUnQuantvec, st->asiLevinsonMem, LP_ORDER+1);
st->asiLevinsonMem[LP_ORDER] = pRCvec[0];
st->asiLevinsonMem[LP_ORDER+1] = pRCvec[1];
}
ippsLPCToISP_AMRWB_16s(pLPCUnQuantvec, pIspvec, st->asiIspOld);
/* Find the interpolated ISPs and convert to pLPCUnQuantvec for all subframes */
{
IPP_ALIGNED_ARRAY(16, short, isp, LP_ORDER);
ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspOld, 18022, pIspvec,14746, isp, LP_ORDER, 15);
ippsISPToLPC_AMRWB_16s(isp, pLPCUnQuantvec, LP_ORDER);
ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspOld, 6554, pIspvec,26214, isp, LP_ORDER, 15);
ippsISPToLPC_AMRWB_16s(isp, &pLPCUnQuantvec[LP_ORDER + 1], LP_ORDER);
ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspOld, 1311, pIspvec,31457, isp, LP_ORDER, 15);
ippsISPToLPC_AMRWB_16s(isp, &pLPCUnQuantvec[2*(LP_ORDER + 1)], LP_ORDER);
/* 4th subframe: pIspvec (frac=1.0) */
ippsISPToLPC_AMRWB_16s(pIspvec, &pLPCUnQuantvec[3*(LP_ORDER + 1)], LP_ORDER);
/* update asiIspOld[] for the next frame */
ippsCopy_16s(pIspvec, st->asiIspOld, LP_ORDER);
}
/* Convert ISPs to frequency domain 0..6400 */
ippsISPToISF_Norm_AMRWB_16s(pIspvec, pIsfvec, LP_ORDER);
/* check resonance for pitch clipping algorithm */
ownCheckGpClipIsf(pIsfvec, st->asiGainPitchClip);
/* Perform PITCH_OL analysis */
pLPCUnQuant = pLPCUnQuantvec;
for (valSubFrame = 0; valSubFrame < FRAME_SIZE; valSubFrame += SUBFRAME_SIZE)
{
ippsMulPowerC_NR_16s_Sfs(pLPCUnQuant, WEIGHT_FACTOR, pLPCvec, LP_ORDER+1, 15);
ippsResidualFilter_AMRWB_16s_Sfs(pLPCvec, LP_ORDER, &pSpeech[valSubFrame], &pWgtSpch[valSubFrame], SUBFRAME_SIZE,10);
pLPCUnQuant += (LP_ORDER + 1);
}
ippsDeemphasize_AMRWB_NR_16s_I(TILT_FACTOR, pWgtSpch, FRAME_SIZE, &(st->siWsp));
/* find maximum value on pWgtSpch[] for 12 bits scaling */
ippsMinMax_16s(pWgtSpch, FRAME_SIZE, &tmp, &max);
max = Abs_16s(max);
tmp = Abs_16s(tmp);
if(tmp > max) max = tmp;
tmp = st->siWspOldMax;
if (max > tmp) tmp = max;
st->siWspOldMax = max;
valShift = Exp_16s(tmp) - 3;
if (valShift > 0) valShift = 0; /* valShift = 0..-3 */
/* decimation of pWgtSpch[] to search pitch in LF and to reduce complexity */
ownLPDecim2(pWgtSpch, FRAME_SIZE, st->asiWspDecimate);
/* scale pWgtSpch[] in 12 bits to avoid overflow */
ownScaleSignal_AMRWB_16s_ISfs(pWgtSpch, FRAME_SIZE / OPL_DECIM, valShift);
/* scale asiWspOld */
valExp += (valShift - st->siWspOldShift);
st->siWspOldShift = valShift;
ownScaleSignal_AMRWB_16s_ISfs(pWgtSpchOldvec, PITCH_LAG_MAX / OPL_DECIM, valExp);
ownScaleSignal_AMRWB_16s_ISfs(st->asiHypassFiltWspOld, PITCH_LAG_MAX / OPL_DECIM, valExp);
st->siScaleExp -= valExp;
/* Find open loop pitch lag for whole speech frame */
pHPWgtSpch = st->asiHypassFiltWspOld + PITCH_LAG_MAX / OPL_DECIM;
if(irate == IPP_SPCHBR_6600) {
ippsHighPassFilter_AMRWB_16s_Sfs(pWgtSpch, pHPWgtSpch, (FRAME_SIZE) / OPL_DECIM, st->pSHPFiltStateWsp,st->siScaleExp);
ippsOpenLoopPitchSearch_AMRWB_16s(pWgtSpch, pHPWgtSpch, &st->siMedianOld, &st->siAdaptiveParam, &pOpenLoopLag[0],
&encoderObj->siToneFlag, &st->siOpenLoopGain,
st->asiPitchLagOld, &st->siWeightFlag, (FRAME_SIZE) / OPL_DECIM);
ippsCopy_16s(&st->asiHypassFiltWspOld[(FRAME_SIZE) / OPL_DECIM],st->asiHypassFiltWspOld,PITCH_LAG_MAX / OPL_DECIM);
pOpenLoopLag[1] = pOpenLoopLag[0];
} else {
ippsHighPassFilter_AMRWB_16s_Sfs(pWgtSpch, pHPWgtSpch, (FRAME_SIZE / 2) / OPL_DECIM, st->pSHPFiltStateWsp,st->siScaleExp);
ippsOpenLoopPitchSearch_AMRWB_16s(pWgtSpch, pHPWgtSpch, &st->siMedianOld, &st->siAdaptiveParam, &pOpenLoopLag[0],
&encoderObj->siToneFlag, &st->siOpenLoopGain,
st->asiPitchLagOld, &st->siWeightFlag, (FRAME_SIZE / 2) / OPL_DECIM);
ippsCopy_16s(&st->asiHypassFiltWspOld[(FRAME_SIZE / 2) / OPL_DECIM],st->asiHypassFiltWspOld,PITCH_LAG_MAX / OPL_DECIM);
ippsHighPassFilter_AMRWB_16s_Sfs(pWgtSpch + ((FRAME_SIZE / 2) / OPL_DECIM), pHPWgtSpch,
(FRAME_SIZE / 2) / OPL_DECIM, st->pSHPFiltStateWsp,st->siScaleExp);
ippsOpenLoopPitchSearch_AMRWB_16s(pWgtSpch + ((FRAME_SIZE / 2) / OPL_DECIM), pHPWgtSpch, &st->siMedianOld, &st->siAdaptiveParam, &pOpenLoopLag[1],
&encoderObj->siToneFlag, &st->siOpenLoopGain,
st->asiPitchLagOld, &st->siWeightFlag, (FRAME_SIZE / 2) / OPL_DECIM);
ippsCopy_16s(&st->asiHypassFiltWspOld[(FRAME_SIZE / 2) / OPL_DECIM],st->asiHypassFiltWspOld,PITCH_LAG_MAX / OPL_DECIM);
}
if (irate == IPP_SPCHBR_DTX) /* CNG mode */
{
ippsResidualFilter_AMRWB_16s_Sfs(&pLPCUnQuantvec[3 * (LP_ORDER + 1)], LP_ORDER, pSpeech, pExc, FRAME_SIZE,10);
ippsRShiftC_16s(pExc, valQNew, pExc2vec, FRAME_SIZE);
ippsEncDTXBuffer_AMRWB_16s(pExc2vec, pIsfvec, &st->dtxEncState.siHistPtr,
st->dtxEncState.asiIsfHistory, st->dtxEncState.siLogEnerHist, valCodecMode);
ownDTXEnc(&st->dtxEncState, pIsfvec, pExc2vec, (unsigned short*)pPrm);
/* Convert ISFs to the cosine domain */
ippsISFToISP_AMRWB_16s(pIsfvec, pIspQuantvec, LP_ORDER);
ippsISPToLPC_AMRWB_16s(pIspQuantvec, pLPCQuantvec, LP_ORDER);
for (valSubFrame = 0; valSubFrame < FRAME_SIZE; valSubFrame += SUBFRAME_SIZE)
{
valCorrGain = ownSynthesis(pLPCQuantvec, &pExc2vec[valSubFrame], 0, &src[valSubFrame * 5 / 4], st);
}
ippsCopy_16s(pIsfvec, st->asiIsfOld, LP_ORDER);
InitEncoder(encoderObj);
ownPrms2Bits(pPrmvec,dst,AMRWB_RATE_DTX);
ippsCopy_16s(&pSpeechOldvec[FRAME_SIZE], st->asiSpeechOld, SPEECH_SIZE - FRAME_SIZE);
ippsCopy_16s(&pWgtSpchOldvec[FRAME_SIZE / OPL_DECIM], st->asiWspOld, PITCH_LAG_MAX / OPL_DECIM);
return APIAMRWB_StsNoErr;
}
ippsISFQuant_AMRWB_16s(pIsfvec, st->asiIsfQuantPast, pIsfvec, (short*)pPrm, irate);
if (irate == IPP_SPCHBR_6600)
pPrm += 5;
else
pPrm += 7;
/* Check stability on pIsfvec : distance between old pIsfvec and current isf */
if (irate == IPP_SPCHBR_23850) {
valStabFac = ownChkStab(pIsfvec, st->asiIsfOld, LP_ORDER-1);
}
ippsCopy_16s(pIsfvec, st->asiIsfOld, LP_ORDER);
/* Convert ISFs to the cosine domain */
ippsISFToISP_AMRWB_16s(pIsfvec, pIspQuantvec, LP_ORDER);
if (st->siFrameFirst != 0)
{
st->siFrameFirst = 0;
ippsCopy_16s(pIspQuantvec, st->asiIspQuantOld, LP_ORDER);
}
/* Find the interpolated ISPs and convert to pIspQuantvec[] for all subframes */
{
IPP_ALIGNED_ARRAY( 16, short, isp, LP_ORDER);
ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspQuantOld, 18022, pIspQuantvec,14746, isp, LP_ORDER, 15);
ippsISPToLPC_AMRWB_16s(isp, pLPCQuantvec, LP_ORDER);
ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspQuantOld, 6554, pIspQuantvec,26214, isp, LP_ORDER, 15);
ippsISPToLPC_AMRWB_16s(isp, &pLPCQuantvec[LP_ORDER + 1], LP_ORDER);
ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspQuantOld, 1311, pIspQuantvec,31457, isp, LP_ORDER, 15);
ippsISPToLPC_AMRWB_16s(isp, &pLPCQuantvec[2*(LP_ORDER + 1)], LP_ORDER);
/* 4th subframe: pIspQuantvec (frac=1.0) */
ippsISPToLPC_AMRWB_16s(pIspQuantvec, &pLPCQuantvec[3*(LP_ORDER + 1)], LP_ORDER);
ippsCopy_16s(pIspQuantvec, st->asiIspQuantOld, LP_ORDER);
}
pLPCQuant = pLPCQuantvec;
for (valSubFrame = 0; valSubFrame < FRAME_SIZE; valSubFrame += SUBFRAME_SIZE)
{
ippsResidualFilter_AMRWB_16s_Sfs(pLPCQuant, LP_ORDER, &pSpeech[valSubFrame], &pExc[valSubFrame], SUBFRAME_SIZE,10);
pLPCQuant += (LP_ORDER + 1);
}
/* Buffer isf's and energy for dtx on non-speech frame */
if (valVadFlag == 0)
{
ippsRShiftC_16s(pExc, valQNew, pExc2vec, FRAME_SIZE);
ippsEncDTXBuffer_AMRWB_16s(pExc2vec, pIsfvec, &st->dtxEncState.siHistPtr,
st->dtxEncState.asiIsfHistory, st->dtxEncState.siLogEnerHist, valCodecMode);
}
/* Loop for every subframe in the analysis frame */
pLPCUnQuant = pLPCUnQuantvec;
pLPCQuant = pLPCQuantvec;
for (valSubFrame = 0,subFrame=0; valSubFrame < FRAME_SIZE; valSubFrame += SUBFRAME_SIZE, subFrame++)
{
ippsSub_16s(st->asiSynthesis, &pSpeech[valSubFrame - LP_ORDER], pErrQuant, LP_ORDER);
ippsResidualFilter_AMRWB_16s_Sfs(pLPCQuant, LP_ORDER, &pSpeech[valSubFrame], &pExc[valSubFrame], SUBFRAME_SIZE,10);
{
short tmp;
tmp = pLPCQuant[0];
pLPCQuant[0] >>= 1;
ippsSynthesisFilter_G729E_16s(pLPCQuant, LP_ORDER, &pExc[valSubFrame], pErrQuant + LP_ORDER, SUBFRAME_SIZE, pErrQuant);
pLPCQuant[0] = tmp;
}
ippsMulPowerC_NR_16s_Sfs(pLPCUnQuant, WEIGHT_FACTOR, pLPCvec, LP_ORDER+1, 15);
ippsResidualFilter_AMRWB_16s_Sfs(pLPCvec, LP_ORDER, pErrQuant + LP_ORDER, pAdptTgtPitch, SUBFRAME_SIZE,10);
ippsDeemphasize_AMRWB_NR_16s_I(TILT_FACTOR, pAdptTgtPitch, SUBFRAME_SIZE, &(st->siSpeechWgt));
ippsZero_16s(pFixCdbkvec, LP_ORDER);
ippsCopy_16s(pAdptTgtPitch, pFixCdbkvec + LP_ORDER, SUBFRAME_SIZE / 2);
tmp = 0;
ippsPreemphasize_AMRWB_16s_ISfs (TILT_FACTOR, pFixCdbkvec + LP_ORDER, SUBFRAME_SIZE / 2, 13, &tmp);
ippsMulPowerC_NR_16s_Sfs(pLPCUnQuant, WEIGHT_FACTOR, pLPCvec, LP_ORDER+1, 15);
{
short tmp;
tmp = pLPCvec[0];
pLPCvec[0] >>= 1;
ippsSynthesisFilter_G729E_16s_I(pLPCvec, LP_ORDER, pFixCdbkvec + LP_ORDER, SUBFRAME_SIZE / 2, pFixCdbkvec);
pLPCvec[0] = tmp;
}
ippsResidualFilter_AMRWB_16s_Sfs(pLPCQuant, LP_ORDER, pFixCdbkvec + LP_ORDER, pResidvec, SUBFRAME_SIZE / 2,10);
ippsCopy_16s(&pExc[valSubFrame + (SUBFRAME_SIZE / 2)], pResidvec + (SUBFRAME_SIZE / 2), SUBFRAME_SIZE / 2);
ippsZero_16s(pErrQuant, LP_ORDER + SUBFRAME_SIZE);
ippsMulPowerC_NR_16s_Sfs(pLPCUnQuant, WEIGHT_FACTOR, pErrQuant + LP_ORDER, LP_ORDER+1, 15);
{
short tmp;
tmp = pLPCQuant[0];
pLPCQuant[0] = 16384;
ippsSynthesisFilter_G729E_16s_I(pLPCQuant, LP_ORDER, pErrQuant + LP_ORDER, SUBFRAME_SIZE, pErrQuant);
pLPCQuant[0] = tmp;
ippsCopy_16s(pErrQuant + LP_ORDER,pImpRespPitchvec,SUBFRAME_SIZE);
}
tmp = 0;
ippsDeemphasize_AMRWB_NR_16s_I(TILT_FACTOR, pImpRespPitchvec, SUBFRAME_SIZE, &tmp);
ippsCopy_16s(pImpRespPitchvec, pImpRespCdbkvec, SUBFRAME_SIZE);
ownScaleSignal_AMRWB_16s_ISfs(pImpRespCdbkvec, SUBFRAME_SIZE, -2);
ownScaleSignal_AMRWB_16s_ISfs(pAdptTgtPitch, SUBFRAME_SIZE, valShift);
ownScaleSignal_AMRWB_16s_ISfs(pImpRespPitchvec, SUBFRAME_SIZE, (short)(1 + valShift));
/* find closed loop fractional pitch lag */
ippsAdaptiveCodebookSearch_AMRWB_16s(pAdptTgtPitch, pImpRespPitchvec, pOpenLoopLag, &valPitchLag, pPitchLagBounds, &pExc[valSubFrame], &valFracPitchLag,
(short*)pPrm, subFrame, irate);
pPrm += 1;
/* Gain clipping test to avoid unstable synthesis on frame erasure */
valClipFlag = ownGpClip(st->asiGainPitchClip);
if ((irate != IPP_SPCHBR_6600)&&(irate != IPP_SPCHBR_8850))
{
ippsConvPartial_NR_16s(&pExc[valSubFrame], pImpRespPitchvec, pFltAdptvec, SUBFRAME_SIZE);
ippsAdaptiveCodebookGainCoeff_AMRWB_16s(pAdptTgtPitch, pFltAdptvec, pGainCoeff, &valGainCoeff, SUBFRAME_SIZE);
if ((valClipFlag != 0) && (valGainCoeff > PITCH_GAIN_CLIP))
valGainCoeff = PITCH_GAIN_CLIP;
ippsInterpolateC_G729_16s_Sfs(pAdptTgtPitch, 16384, pFltAdptvec,(short)(-valGainCoeff), pCorrvec, SUBFRAME_SIZE, 14); /* pCorrvec used temporary */
} else
{
valGainCoeff = 0;
}
/* find pitch excitation with lp filter */
pSrcCoeff[0] = 20972;
pSrcCoeff[1] = -5898;
ippsHighPassFilter_Direct_AMRWB_16s(pSrcCoeff, &pExc[valSubFrame], pFixCdbkvec, SUBFRAME_SIZE, 1);
ippsConvPartial_NR_16s(pFixCdbkvec, pImpRespPitchvec, pFltAdpt2vec, SUBFRAME_SIZE);
ippsAdaptiveCodebookGainCoeff_AMRWB_16s(pAdptTgtPitch, pFltAdpt2vec, pGainCoeff2, &valAdptGain, SUBFRAME_SIZE);
if ((valClipFlag != 0) && (valAdptGain > PITCH_GAIN_CLIP))
valAdptGain = PITCH_GAIN_CLIP;
ippsInterpolateC_G729_16s_Sfs(pAdptTgtPitch, 16384, pFltAdpt2vec,(short)(-valAdptGain), pAdptTgtCdbk, SUBFRAME_SIZE, 14);
valSelect = 0;
if ((irate != IPP_SPCHBR_6600)&&(irate != IPP_SPCHBR_8850))
{
int valCorrSum, valCdbkSum;
ippsDotProd_16s32s_Sfs( pCorrvec, pCorrvec,SUBFRAME_SIZE, &valCorrSum, 0);
ippsDotProd_16s32s_Sfs( pAdptTgtCdbk, pAdptTgtCdbk,SUBFRAME_SIZE, &valCdbkSum, 0);
if (valCorrSum <= valCdbkSum) valSelect = 1;
*(pPrm)++ = valSelect;
}
if (valSelect == 0)
{
/* use the lp filter for pitch excitation prediction */
valPitchGain = valAdptGain;
ippsCopy_16s(pFixCdbkvec, &pExc[valSubFrame], SUBFRAME_SIZE);
ippsCopy_16s(pFltAdpt2vec, pFltAdptvec, SUBFRAME_SIZE);
ippsCopy_16s(pGainCoeff2, pGainCoeff, 4);
} else
{
/* no filter used for pitch excitation prediction */
valPitchGain = valGainCoeff;
ippsCopy_16s(pCorrvec, pAdptTgtCdbk, SUBFRAME_SIZE);
}
ippsInterpolateC_G729_16s_Sfs(pResidvec, 16384, &pExc[valSubFrame],(short)(-valPitchGain), pResidvec, SUBFRAME_SIZE, 14);
ownScaleSignal_AMRWB_16s_ISfs(pResidvec, SUBFRAME_SIZE, valShift);
tmp = 0;
ippsPreemphasize_AMRWB_16s_ISfs (st->siTiltCode, pImpRespCdbkvec, SUBFRAME_SIZE, 14, &tmp);
if (valFracPitchLag > 2) valPitchLag += 1;
if (valPitchLag < SUBFRAME_SIZE) {
ippsHarmonicFilter_NR_16s(PITCH_SHARP_FACTOR, valPitchLag, &pImpRespCdbkvec[valPitchLag], &pImpRespCdbkvec[valPitchLag], SUBFRAME_SIZE-valPitchLag);
}
ippsAlgebraicCodebookSearch_AMRWB_16s(pAdptTgtCdbk, pResidvec, pImpRespCdbkvec, pFixCdbkvec, pFltAdpt2vec, irate, (short*)pPrm);
if (irate == IPP_SPCHBR_6600)
{
pPrm += 1;
} else if ((irate == IPP_SPCHBR_8850) || (irate == IPP_SPCHBR_12650) ||
(irate == IPP_SPCHBR_14250) || (irate == IPP_SPCHBR_15850))
{
pPrm += 4;
} else
{
pPrm += 8;
}
tmp = 0;
ippsPreemphasize_AMRWB_16s_ISfs (st->siTiltCode, pFixCdbkvec, SUBFRAME_SIZE, 14, &tmp);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -