encg729.c

G.729 and G.723.1 codecs x86 (and x86_64) Linux and FreeBSD source code for Asterisk open source PBX

        }
    }
    return APIG729_StsNoErr;
}

APIG729_Status G729Encode
(G729Encoder_Obj* encoderObj,const Ipp16s *src, Ipp8u* dst, G729Codec_Type codecType , Ipp32s *frametype) {

    LOCAL_ALIGN_ARRAY(32, Ipp16s, impResp, LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, val1, LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, tmpVec2, LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, codeword, LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, y1, LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, y2, LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, pAp_t,(LPF_DIM+1)*2,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, pAq_t,(LPF_DIM+1)*2,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, tmpvec, BWLPCF_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, pAp1, BWLPCF1_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, tmp_not_used,LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, pAp2, BWLPCF1_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, interpLSF, LPF_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, newLSF, LPF_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp32s,   BWDacf, BWLPCF1_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp32s,   BWDacfHigh, BWLPCF1_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, BWDrc,BWLPCF_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, pBwdLPC2,2*BWLPCF1_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, nullArr, LP_SUBFRAME_DIM,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, LTPresid, LP_SUBFRAME_DIM,encoderObj);

    LOCAL_ARRAY(Ipp16s,indexFC,2,encoderObj);
    LOCAL_ARRAY(Ipp16s,delay,2,encoderObj);
    LOCAL_ARRAY(Ipp16s,LAR,4,encoderObj);
    LOCAL_ARRAY(Ipp16s,wfact1,2,encoderObj);
    LOCAL_ARRAY(Ipp16s,wfact2,2,encoderObj);
    LOCAL_ARRAY(Ipp16s,LSPcode,2,encoderObj);
    LOCAL_ARRAY(Ipp16s,freqNow,LPF_DIM,encoderObj);
    Ipp16s *pAq, *pAp, bestOPLag, index, gainAc, gainCode, gainPit, tmp, improveFlag, subfr;
    Ipp8s *synFltw = encoderObj->synFltw;
    Ipp16s *pAna = encoderObj->encPrm,*anau;
    Ipp16s *speechHistory = encoderObj->speechHistory;
    Ipp16s *prevSubfrLSP = encoderObj->prevSubfrLSP;
    Ipp16s *prevSubfrLSPquant = encoderObj->prevSubfrLSPquant;
    Ipp16s betaPreFilter = encoderObj->betaPreFilter;
    Ipp16s *resFilMem0  = encoderObj->resFilMem0;
    Ipp16s *prevWgtSpeech = encoderObj->prevWgtSpeech;
    Ipp16s *wsp = prevWgtSpeech + MAX_PITCH_LAG;
    Ipp16s *prevExcitat = encoderObj->prevExcitat;
    Ipp16s *exc = prevExcitat + L_prevExcitat;
    Ipp32s   i, j, subfrIdx, valOpenDelay;
    Ipp16s vadEnable = (Ipp16s)(encoderObj->objPrm.mode == G729Encode_VAD_Enabled);
    Ipp8s *synFltw0 = encoderObj->synFltw0;
    Ipp16s *resFilMem  = encoderObj->resFilMem;
    Ipp16s *error  = resFilMem + BWLPCF_DIM;
    Ipp16s lpMode = 0;
    Ipp16s satFilt;
    Ipp16s mAp, mAq, m_a;
    Ipp16s *ppAp, *ppAq;
    Ipp16s tmp1, tmp2,avgLag;

    VADmemory_Obj* vM =  (VADmemory_Obj*)encoderObj->vadMem;
    if(NULL==src || NULL ==dst)
        return APIG729_StsBadArgErr;
    if(encoderObj->preProc == NULL)
        return APIG729_StsNotInitialized;
    if((codecType != G729_CODEC)&&(codecType != G729D_CODEC)&&(codecType != G729E_CODEC))
        return APIG729_StsBadCodecType;
    if(encoderObj->objPrm.objSize <= 0)
        return APIG729_StsNotInitialized;
    if(ENC_KEY != encoderObj->objPrm.key)
        return APIG729_StsBadCodecType;
    if(encoderObj->objPrm.codecType != G729I_CODEC) encoderObj->codecType = encoderObj->objPrm.codecType;
    else encoderObj->codecType = codecType;
    ippsZero_16s(nullArr, LP_SUBFRAME_DIM);
    ippsCopy_16s(src,encoderObj->speechHistory + SPEECH_BUF_DIM - LP_FRAME_DIM,LP_FRAME_DIM);
    ippsHighPassFilter_G729_16s_ISfs(
                                    encoderObj->speechHistory + SPEECH_BUF_DIM - LP_FRAME_DIM,LP_FRAME_DIM,12,encoderObj->preProc);
    {
        LOCAL_ALIGN_ARRAY(32, Ipp16s, rCoeff, LPF_DIM,encoderObj);
        LOCAL_ALIGN_ARRAY(32, Ipp16s, newLSP, LPF_DIM,encoderObj);
        LOCAL_ALIGN_ARRAY(32, Ipp16s, newQlsp, LPF_DIM+1,encoderObj);
        LOCAL_ALIGN_ARRAY(32, Ipp32s, autoR, VAD_LPC_DIM +2,encoderObj);
        LOCAL_ALIGN_ARRAY(32, Ipp16s, yVal, LP_WINDOW_DIM,encoderObj);
        Ipp16s Vad=1;
        Ipp16s norma;
        Ipp16s *rhNBE = &newQlsp[0];
        norma=1;
        ippsMul_NR_16s_Sfs(LPC_WINDOW,hammingWin,yVal,LP_WINDOW_DIM,15);
        j = LPF_DIM;
        if(vadEnable == 1)
            j = VAD_LPC_DIM ;
        while(ippsAutoCorr_NormE_16s32s(yVal,LP_WINDOW_DIM,autoR,j+1,&i)!=ippStsNoErr) {
            ippsRShiftC_16s_I(2,yVal,LP_WINDOW_DIM);
            norma+=4;
        }
        norma = (Ipp16s)(norma - i);
        for(i=0;i<LPF_DIM+1;i++)
            rhNBE[i] = (Ipp16s)(autoR[i]>>16);
        ippsLagWindow_G729_32s_I(autoR+1,VAD_LPC_DIM );
        if(ippsLevinsonDurbin_G729_32s16s(autoR, LPF_DIM, &pAp_t[LPF_DIM+1], rCoeff, &tmp ) == ippStsOverflow) {
            for(i=0; i<=LPF_DIM; i++) {
                pAp_t[LPF_DIM+1+i] = encoderObj->prevSubfrLPC[i];
            }
            rCoeff[0] = encoderObj->prevRC[0];
            rCoeff[1] = encoderObj->prevRC[1];
        } else {
            for(i=0; i<=LPF_DIM; i++) encoderObj->prevSubfrLPC[i] = pAp_t[LPF_DIM+1+i];
            encoderObj->prevRC[0] = rCoeff[0];
            encoderObj->prevRC[1] = rCoeff[1];
        }
        ippsLPCToLSP_G729_16s(&pAp_t[LPF_DIM+1], prevSubfrLSP, newLSP);
        if(vadEnable == 1) {
            ippsLSPToLSF_Norm_G729_16s(newLSP, newLSF);
            {
                LOCAL_ALIGN_ARRAY(32, Ipp16s, vecTmp_VAD_LPC_DIMP1, VAD_LPC_DIM +1, encoderObj);
                VoiceActivityDetect_G729(LPC_WINDOW,newLSF,autoR,norma,rCoeff[1],&Vad,encoderObj->vadMem, vecTmp_VAD_LPC_DIMP1);
                LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, vecTmp_VAD_LPC_DIMP1, VAD_LPC_DIM +1, encoderObj);
            }
            VADMusicDetection( encoderObj->codecType, autoR[0], norma,rCoeff ,encoderObj->pLag , encoderObj->pGain,
                               encoderObj->prevLPmode, &Vad,encoderObj->vadMem);
            CNG_Update(rhNBE,norma,Vad,encoderObj);
            if(Vad==0) {
                ippsMove_16s(&encoderObj->BWDsynth[LP_FRAME_DIM], &encoderObj->BWDsynth[0], SYNTH_BWD_DIM);
                if( encoderObj->prevLPmode == 0) {
                    ippsInterpolate_G729_16s(newLSP,prevSubfrLSP,tmpvec,LPF_DIM);
                    ippsLSPToLPC_G729_16s(tmpvec,pAp_t);
                    ippsLSPToLSF_Norm_G729_16s(tmpvec, interpLSF);
                    ippsLSPToLSF_Norm_G729_16s(newLSP, newLSF);
                } else {

                    ippsLSPToLPC_G729_16s(newLSP,pAp_t);
                    ippsLSPToLSF_Norm_G729_16s(newLSP, newLSF);
                    ippsCopy_16s(newLSF, interpLSF, LPF_DIM);
                }
                if(encoderObj->statGlobal > 10000) {
                    encoderObj->statGlobal -= 2621;
                    if( encoderObj->statGlobal < 10000)
                        encoderObj->statGlobal = 10000 ;
                }
                lpMode = 0;
                encoderObj->dominantBWDmode = 0;
                encoderObj->interpCoeff2_2 = 4506;

                /* the next frame's LSPs update*/
                ippsCopy_16s(newLSP, prevSubfrLSP, LPF_DIM);

                _ippsRCToLAR_G729_16s(rCoeff,LAR+2,2);
                ippsInterpolate_G729_16s(encoderObj->prevLAR,LAR+2,LAR,2);
                encoderObj->prevLAR[0] = LAR[2];
                encoderObj->prevLAR[1] = LAR[3];
                {
                    LOCAL_ALIGN_ARRAY(32, Ipp16s, PWGammaFactorMem, LPF_DIM, encoderObj);
                    _ippsPWGammaFactor_G729_16s(LAR,interpLSF,&encoderObj->prevSubfrSmooth,wfact1,wfact2, PWGammaFactorMem);
                    _ippsPWGammaFactor_G729_16s(LAR+2,newLSF,&encoderObj->prevSubfrSmooth,wfact1+1,wfact2+1, PWGammaFactorMem);
                    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, PWGammaFactorMem, LPF_DIM, encoderObj);
                }
                CNG_encoder(prevExcitat, prevSubfrLSPquant, pAq_t, pAna, encoderObj);
                if(*pAna==2)
                    *pAna=1;
                vM->VADPPrev = vM->VADPrev;
                vM->VADPrev = Vad;
                vad_update_I(pAq_t, pAp_t, exc, PRESENT_SPEECH, val1,
                             wsp,  resFilMem0,  synFltw,  synFltw0, wfact1, wfact2,
                             pAp1, pAp2, resFilMem, error, encoderObj->pSynth, encoderObj->pGain);
                ippsCopy_16s(&pAq_t[LPF_DIM+1], encoderObj->pPrevFilt, LPF_DIM+1);
                for(i=LPF_DIM+1; i <BWLPCF1_DIM; i++) encoderObj->pPrevFilt[i] = 0;
                encoderObj->prevLPmode = lpMode;
                encoderObj->betaPreFilter = PITCH_SHARP_MIN;
                ippsMove_16s(&speechHistory[LP_FRAME_DIM], &speechHistory[0], SPEECH_BUF_DIM-LP_FRAME_DIM);
                ippsMove_16s(&prevWgtSpeech[LP_FRAME_DIM], &prevWgtSpeech[0], MAX_PITCH_LAG);
                ippsMove_16s(&prevExcitat[LP_FRAME_DIM], &prevExcitat[0], MAX_PITCH_LAG+INTERPOLATION_FILTER_DIM);
                anau = encoderObj->encPrm+1;
                if(pAna[0] == 0) {
                    *frametype=0;
                } else {
                    *frametype=1;
                    dst[0] = (Ipp8u)(((anau[0] & 1) << 7) | ((anau[1] & 31) << 2) | ((anau[2] & 15)>>2));
                    dst[1] = (Ipp8u)(((anau[2] & 3) << 6) | ((anau[3] & 31) << 1));
                }
                CLEAR_SCRATCH_MEMORY(encoderObj);
                return APIG729_StsNoErr;
            }
        }

        *pAna++ = CodecTypeToRate[encoderObj->codecType];
        encoderObj->seed = SEED_INIT;
        vM->VADPPrev = vM->VADPrev;
        vM->VADPrev = Vad;
        encoderObj->CNGidx = 0;
        LOCAL_ALIGN_ARRAY_FREE(32,Ipp16s, yVal, LP_WINDOW_DIM,encoderObj);

        if(encoderObj->codecType == G729_CODEC) {
            ippsLSPQuant_G729_16s(newLSP,(Ipp16s*)encoderObj->prevLSPfreq,newQlsp,pAna);
            pAna += 2;
        } else {
            if(encoderObj->codecType == G729E_CODEC) {
                ippsWinHybrid_G729E_16s32s(encoderObj->BWDsynth, BWDacf,
                                           (IppsWinHybridState_G729E_16s*)&encoderObj->hwState);
                BWDLagWindow(BWDacf, BWDacfHigh);
                if(ippsLevinsonDurbin_G729_32s16s(BWDacfHigh, BWLPCF_DIM, &pBwdLPC2[BWLPCF1_DIM], BWDrc, &tmp )
                   == ippStsOverflow) {
                    for(i=0; i<=BWLPCF_DIM; i++) {
                        pBwdLPC2[BWLPCF1_DIM+i] = encoderObj->pPrevBwdLPC[i];
                    }
                    BWDrc[0] = encoderObj->pPrevBwdRC[0];
                    BWDrc[1] = encoderObj->pPrevBwdRC[1];
                } else {
                    for(i=0; i<=BWLPCF_DIM; i++) encoderObj->pPrevBwdLPC[i] = pBwdLPC2[BWLPCF1_DIM+i];
                    encoderObj->pPrevBwdRC[0] = BWDrc[0];
                    encoderObj->pPrevBwdRC[1] = BWDrc[1];
                }

                satFilt = 0;
                for(i=BWLPCF1_DIM; i<2*BWLPCF1_DIM; i++) if(pBwdLPC2[i] >= IPP_MAX_16S)
                        satFilt = 1;
                if(satFilt == 1)
                    ippsCopy_16s(encoderObj->pBwdLPC2, &pBwdLPC2[BWLPCF1_DIM], BWLPCF1_DIM);
                else
                    ippsCopy_16s(&pBwdLPC2[BWLPCF1_DIM], encoderObj->pBwdLPC2, BWLPCF1_DIM);

                ippsMulPowerC_NR_16s_Sfs(&pBwdLPC2[BWLPCF1_DIM], N0_98, &pBwdLPC2[BWLPCF1_DIM], BWLPCF1_DIM,15);
            }
            ippsMove_16s(&encoderObj->BWDsynth[LP_FRAME_DIM], &encoderObj->BWDsynth[0], SYNTH_BWD_DIM);
            ippsLSPQuant_G729E_16s(newLSP,(const Ipp16s*)encoderObj->prevLSPfreq,freqNow,newQlsp,LSPcode);
        }

        if( encoderObj->prevLPmode == 0) {

            ippsInterpolate_G729_16s(newLSP,prevSubfrLSP,tmpvec,LPF_DIM);
            ippsLSPToLPC_G729_16s(tmpvec,pAp_t);
            ippsLSPToLSF_Norm_G729_16s(tmpvec, interpLSF);
            ippsLSPToLSF_Norm_G729_16s(newLSP, newLSF);

            ippsInterpolate_G729_16s(newQlsp,prevSubfrLSPquant,tmpvec,LPF_DIM);

            ippsLSPToLPC_G729_16s(tmpvec,&pAq_t[0]);
            ippsLSPToLPC_G729_16s(newQlsp,&pAq_t[LPF_DIM+1]);
        } else {
            ippsLSPToLPC_G729_16s(newLSP,pAp_t);
            ippsLSPToLSF_Norm_G729_16s(newLSP, newLSF);
            ippsCopy_16s(newLSF, interpLSF, LPF_DIM);
            ippsLSPToLPC_G729_16s(newQlsp,&pAq_t[LPF_DIM+1]);
            ippsMove_16s(&pAq_t[LPF_DIM+1], pAq_t, LPF_DIM+1);
        }
        if(encoderObj->codecType == G729E_CODEC) {
            SetLPCMode_G729E(PRESENT_SPEECH, pAq_t, pBwdLPC2, &lpMode,
                             newLSP, prevSubfrLSP, encoderObj);
        }

        /* the next frame's LSPs update*/

        ippsCopy_16s(newLSP,prevSubfrLSP,LPF_DIM);
        if(lpMode==0) {
            ippsCopy_16s(newQlsp,prevSubfrLSPquant,LPF_DIM);
            _ippsRCToLAR_G729_16s(rCoeff,LAR+2,2);
            mAq = LPF_DIM;
            mAp = LPF_DIM;
            if(encoderObj->dominantBWDmode == 0)
                pAp = pAp_t;
            else
                pAp = pAq_t;
            pAq = pAq_t;
            tmp = (Ipp16s)(encoderObj->prevLAR[0] + LAR[2]);
            LAR[0] = (Ipp16s)((tmp<0)? ~(( ~tmp) >> 1 ) : tmp>>1);
            tmp = (Ipp16s)(encoderObj->prevLAR[1] + LAR[3]);
            LAR[1] = (Ipp16s)((tmp<0)? ~(( ~tmp) >> 1 ) : tmp>>1);
            encoderObj->prevLAR[0] = LAR[2];
            encoderObj->prevLAR[1] = LAR[3];
            {
                LOCAL_ALIGN_ARRAY(32, Ipp16s, PWGammaFactorMem, LPF_DIM, encoderObj);
                _ippsPWGammaFactor_G729_16s(LAR,interpLSF,&encoderObj->prevSubfrSmooth,wfact1,wfact2, PWGammaFactorMem);
                _ippsPWGammaFactor_G729_16s(LAR+2,newLSF,&encoderObj->prevSubfrSmooth,wfact1+1,wfact2+1, PWGammaFactorMem);
                LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, PWGammaFactorMem, LPF_DIM, encoderObj);
            }
            ippsMulPowerC_NR_16s_Sfs(&pAp[0],wfact1[0], pAp1,LPF_DIM+1,15);
            ippsMulPowerC_NR_16s_Sfs(&pAp[0],wfact2[0], pAp2,LPF_DIM+1,15);

            ippsResidualFilter_G729_16s(&PRESENT_SPEECH[0],pAp1, &wsp[0]);
            ippsSynthesisFilterLow_NR_16s_ISfs(pAp2,wsp,LP_SUBFRAME_DIM,12,((SynthesisFilterState*)synFltw)->buffer+20);
            ippsCopy_16s((wsp+LP_SUBFRAME_DIM-30), ((SynthesisFilterState*)synFltw)->buffer, 30);

            ippsMulPowerC_NR_16s_Sfs(&pAp[LPF_DIM+1],wfact1[1], pAp1,LPF_DIM+1,15);
            ippsMulPowerC_NR_16s_Sfs(&pAp[LPF_DIM+1],wfact2[1], pAp2,LPF_DIM+1,15);
            ippsResidualFilter_G729_16s(&PRESENT_SPEECH[LP_SUBFRAME_DIM], pAp1, &wsp[LP_SUBFRAME_DIM]);
            ippsSynthesisFilterLow_NR_16s_ISfs(pAp2,&wsp[LP_SUBFRAME_DIM],LP_SUBFRAME_DIM,12,((SynthesisFilterState*)synFltw)->buffer+20);
            ippsCopy_16s((&wsp[LP_SUBFRAME_DIM]+LP_SUBFRAME_DIM-30), ((SynthesisFilterState*)synFltw)->buffer, 30);

            ippsOpenLoopPitchSearch_G729_16s(wsp, &bestOPLag);