encg729.c

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

            if((encoderObj->codecType != G729_CODEC)) {
                if(encoderObj->codecType == G729E_CODEC)
                    *pAna++ = lpMode;

                for( i = LSP_MA_ORDER-1 ; i > 0 ; i-- )
                    ippsMove_16s(encoderObj->prevLSPfreq[i-1], encoderObj->prevLSPfreq[i], LPF_DIM);
                ippsCopy_16s(freqNow, encoderObj->prevLSPfreq[0], LPF_DIM);
                *pAna++ = LSPcode[0]; *pAna++ = LSPcode[1];
            }
            ippsCopy_16s(&pAq[LPF_DIM+1], encoderObj->pPrevFilt, LPF_DIM+1);
            ippsZero_16s(encoderObj->pPrevFilt+LPF_DIM+1,BWLPCF1_DIM-LPF_DIM-1);
            ippsZero_16s(encoderObj->zeroPostFiltVec1+LPF_DIM+1,BWLPCF1_DIM-LPF_DIM-1);

            for(i= 0; i< 4; i++)
                encoderObj->pLag[i] = encoderObj->pLag[i+1];

            avgLag = (Ipp16s)(encoderObj->pLag[0]+encoderObj->pLag[1]);
            avgLag = (Ipp16s)(avgLag + encoderObj->pLag[2]);
            avgLag = (Ipp16s)(avgLag + encoderObj->pLag[3]);
            avgLag = (Ipp16s)((avgLag * BWF_HARMONIC_E + (Ipp32s)BWF_HARMONIC)>>15);

            tmp1 = (Ipp16s)(bestOPLag - (avgLag<<1));
            tmp2 = (Ipp16s)(bestOPLag - ((avgLag<<1)+avgLag));
            if( Abs_16s(tmp1) < 4) {
                encoderObj->pLag[4] = (Ipp16s)(bestOPLag>>1);
            } else if( Abs_16s(tmp2) < 6) {
                encoderObj->pLag[4] = (Ipp16s)((bestOPLag * 10923)>>15);
            } else {
                encoderObj->pLag[4] = bestOPLag;
            }
        } else {
            if(encoderObj->dominantBWDmode == 0) {
                mAp = LPF_DIM; pAp = pAp_t;
                wfact1[0] = wfact1[1] = COEFF1;
                wfact2[0] = wfact2[1] = 13107;
            } else {
                mAp = BWLPCF_DIM; pAp = pBwdLPC2;
                wfact1[0] = wfact1[1] = 32112;
                wfact2[0] = wfact2[1] = 13107;
            }

            ppAp = pAp;
            pAq = pBwdLPC2;
            mAq = BWLPCF_DIM;

            if(encoderObj->dominantBWDmode == 0) {
                for(j=LPF_DIM+1; j<BWLPCF1_DIM; j++) encoderObj->zeroPostFiltVec1[j] = 0;
            }
            /* next frame's previous filter update */
            ippsCopy_16s(&pAq[BWLPCF1_DIM], encoderObj->pPrevFilt, BWLPCF1_DIM);

            ippsMulPowerC_NR_16s_Sfs(&pAp[0],wfact1[0], pAp1,mAp+1,15);
            ippsMulPowerC_NR_16s_Sfs(&pAp[0],wfact2[0], pAp2,mAp+1,15);

            ippsResidualFilter_G729E_16s( pAp1, mAp,&PRESENT_SPEECH[0], &wsp[0], LP_SUBFRAME_DIM);
            SynthesisFilterOvf_G729_16s_I(pAp2,wsp,LP_SUBFRAME_DIM,synFltw,BWLPCF_DIM-mAp);

            /* weighted speech signal for 2-nd subframe */
            ippsMulPowerC_NR_16s_Sfs(&pAp[mAp+1],wfact1[1], pAp1,mAp+1,15);
            ippsMulPowerC_NR_16s_Sfs(&pAp[mAp+1],wfact2[1], pAp2,mAp+1,15);
            ippsResidualFilter_G729E_16s( pAp1,mAp, &PRESENT_SPEECH[LP_SUBFRAME_DIM], &wsp[LP_SUBFRAME_DIM], LP_SUBFRAME_DIM);
            SynthesisFilterOvf_G729_16s_I(pAp2,&wsp[LP_SUBFRAME_DIM],LP_SUBFRAME_DIM,synFltw,BWLPCF_DIM-mAp);
            if(encoderObj->codecType == G729E_CODEC) *pAna++ = lpMode;
            ippsOpenLoopPitchSearch_G729_16s(wsp, &bestOPLag);

            for(i= 0; i< 4; i++)
                encoderObj->pLag[i] = encoderObj->pLag[i+1];
            avgLag = (Ipp16s)(encoderObj->pLag[0]+encoderObj->pLag[1]);
            avgLag = (Ipp16s)(avgLag + encoderObj->pLag[2]);
            avgLag = (Ipp16s)(avgLag + encoderObj->pLag[3]);
            avgLag = (Ipp16s)((avgLag * BWF_HARMONIC_E)>>15);
            tmp1 = (Ipp16s)(bestOPLag - (avgLag<<1));
            tmp2 = (Ipp16s)(bestOPLag - ((avgLag<<1)+avgLag));
            if( Abs_16s(tmp1) < 4) {
                encoderObj->pLag[4] = (Ipp16s)(bestOPLag>>1);
            } else if( Abs_16s(tmp2) < 6) {
                encoderObj->pLag[4] = (Ipp16s)((bestOPLag * 10923)>>15);
            } else {
                encoderObj->pLag[4] = bestOPLag;
            }
        }
        LOCAL_ALIGN_ARRAY_FREE(32, Ipp32s, autoR, VAD_LPC_DIM +2,encoderObj);
        LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, newQlsp, LPF_DIM+1,encoderObj);
        LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, newLSP, LPF_DIM,encoderObj);
        LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, rCoeff, LPF_DIM,encoderObj);
    }
    ppAp = pAp;
    ppAq = pAq;
    valOpenDelay=bestOPLag;
    subfr = 0;
    for(subfrIdx = 0;  subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {

        ippsMulPowerC_NR_16s_Sfs(ppAp,wfact1[subfr], pAp1,mAp+1,15);
        ippsMulPowerC_NR_16s_Sfs(ppAp,wfact2[subfr], pAp2,mAp+1,15);
        subfr++;

        ippsCopy_16s(pAp1,encoderObj->zeroPostFiltVec1,mAp+1);

        ippsSynthesisFilter_G729E_16s(ppAq, mAq,  encoderObj->zeroPostFiltVec1, impResp, LP_SUBFRAME_DIM, nullArr);
        ippsSynthesisFilter_G729E_16s_I(pAp2, mAp, impResp, LP_SUBFRAME_DIM, nullArr);

        ippsResidualFilter_G729E_16s( ppAq,mAq, &PRESENT_SPEECH[subfrIdx], &exc[subfrIdx], LP_SUBFRAME_DIM);
        ippsCopy_16s(&exc[subfrIdx],LTPresid,LP_SUBFRAME_DIM);
        ippsSynthesisFilter_G729E_16s(ppAq, mAq, &exc[subfrIdx], error, LP_SUBFRAME_DIM, &resFilMem[BWLPCF_DIM-mAq]);

        ippsResidualFilter_G729E_16s( pAp1, mAp,error, val1, LP_SUBFRAME_DIM);
        ippsSynthesisFilter_G729E_16s_I(pAp2, mAp, val1, LP_SUBFRAME_DIM, &resFilMem0[BWLPCF_DIM-mAp]);

        if(encoderObj->codecType == G729D_CODEC) {
            ippsAdaptiveCodebookSearch_G729D_16s((Ipp16s)valOpenDelay, val1,impResp,&prevExcitat[subfrIdx],(Ipp16s)(subfrIdx!=0),delay);
        } else {

            ippsAdaptiveCodebookSearch_G729_16s((Ipp16s)valOpenDelay, val1,impResp,&prevExcitat[subfrIdx],delay,tmp_not_used,(Ipp16s)(subfrIdx!=0));
        }

         if(subfrIdx == 0) {  /* 1-st subframe */
            if(delay[0] <= 85) {
                index = (Ipp16s)(3 * (delay[0] - 19) + delay[1] - 1);
            } else {
                index = (Ipp16s)(delay[0] - 85 + 197);
            }
        } else { /* 2-nd subframe */
            i = valOpenDelay - 5;
            if(i < MIN_PITCH_LAG) {
                i = MIN_PITCH_LAG;
            }
            if(i + 9 > MAX_PITCH_LAG) {
                i = MAX_PITCH_LAG - 9;
            }
            if(encoderObj->codecType == G729D_CODEC) {
                i = delay[0] - i;
                if(i < 3)
                    index = (Ipp16s)i;
                else if(i < 7) {
                    index = (Ipp16s)((i - 3) * 3 + delay[1] + 3);
                } else {
                    index = (Ipp16s)(i + 6);
                }
            } else {
                index = (Ipp16s)((delay[0] - i)*3 + 2 + delay[1]);
            }
        }
        valOpenDelay=delay[0];
        *pAna++ = index; /* Pitch delay for the current 1-st or 2-nd subframe  */
        if( (subfrIdx == 0) && (encoderObj->codecType != G729D_CODEC) ) {
            *pAna = (Ipp16s)equality(index);
            if( encoderObj->codecType == G729E_CODEC) *pAna = (Ipp16s)(*pAna ^ ((index>>1) & 1));
            pAna++;
        }
        if(encoderObj->codecType == G729_CODEC) {

            ippsAdaptiveCodebookGain_G729_16s(val1,impResp,&exc[subfrIdx],y1,&gainAc);
        } else {
            if(encoderObj->codecType == G729D_CODEC)
                ippsDecodeAdaptiveVector_G729_16s_I(delay,&prevExcitat[subfrIdx]);

            ippsAdaptiveCodebookGain_G729_16s(val1,impResp,&exc[subfrIdx],y1,&gainAc);
        }
        if(delay[1] > 0) {
            i = delay[0] + 1;
        } else {
            i = delay[0];
        }
        improveFlag = calcErr_G729(i, encoderObj->coderErr);
        if(improveFlag && gainAc > PITCH_GAIN_MAX) gainAc = PITCH_GAIN_MAX;

        ippsAdaptiveCodebookContribution_G729_16s(gainAc,y1,val1,tmpVec2);

        betaPreFilter = (Ipp16s)(betaPreFilter << 1);
        if(valOpenDelay < LP_SUBFRAME_DIM)
            ippsHarmonicFilter_16s_I(betaPreFilter,valOpenDelay,&impResp[valOpenDelay],LP_SUBFRAME_DIM-valOpenDelay);

        switch(encoderObj->codecType) {
            case G729_CODEC:
                {

                    LOCAL_ALIGN_ARRAY(32, Ipp32s, rr, CORR_DIM, encoderObj);
                    LOCAL_ALIGN_ARRAY(32, Ipp16s, Dn, LP_SUBFRAME_DIM, encoderObj);
                    ippsCrossCorr_NormM_16s(impResp,tmpVec2,LP_SUBFRAME_DIM,Dn);

                    ippsToeplizMatrix_G729_16s32s(impResp, rr);
                    ippsFixedCodebookSearch_G729_32s16s(Dn, rr, codeword,indexFC,&encoderObj->extraTime, (Ipp16s)subfrIdx);
                    CodewordImpConv_G729(indexFC[1],codeword,impResp,y2);

                    *pAna++ = indexFC[1]; /*  index  of positions */
                    *pAna++ = indexFC[0]; /*  index of signs  */

                    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, Dn, LP_SUBFRAME_DIM, encoderObj);
                    LOCAL_ALIGN_ARRAY_FREE(32, Ipp32s, rr, CORR_DIM, encoderObj);
                    break;
                }
            case G729D_CODEC:
                {
                    LOCAL_ALIGN_ARRAY(32, Ipp16s, Dn, LP_SUBFRAME_DIM, encoderObj);
                    Ipp16s sTmpSignIndexes;

                    /*  target vector with impulse response correlation */
                    ippsCrossCorr_NormM_16s(impResp,tmpVec2,LP_SUBFRAME_DIM,Dn);

                    ippsFixedCodebookSearch_G729D_16s( Dn, impResp, codeword, y2, &sTmpSignIndexes,&index);

                    *pAna++ = index;/*  index  of positions */
                    *pAna++ = sTmpSignIndexes;  /*  index of signs  */
                    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, Dn, LP_SUBFRAME_DIM, encoderObj);
                    break;

                }
            case G729E_CODEC:
                {

                    /* calculate residual after LTP */
                    ippsAdaptiveCodebookContribution_G729_16s(gainAc,&exc[subfrIdx],LTPresid,LTPresid);
                    /* lpMode - 0=Forward, 1=Backward*/
                    ippsFixedCodebookSearch_G729E_16s(lpMode,tmpVec2, LTPresid, impResp, codeword, y2, pAna);
                    pAna += 5;
                    break;
                }
            default:
                {
                    LOCAL_ALIGN_ARRAY(32, Ipp32s, rr, CORR_DIM, encoderObj);
                    LOCAL_ALIGN_ARRAY(32, Ipp16s, Dn, LP_SUBFRAME_DIM, encoderObj);
                    /* correlation of target vector with impulse response */
                    ippsCrossCorr_NormM_16s(impResp,tmpVec2,LP_SUBFRAME_DIM,Dn);

                    /*  impulse response auto correlation matrix */
                    ippsToeplizMatrix_G729_16s32s(impResp, rr);
                    ippsFixedCodebookSearch_G729_32s16s(Dn, rr, codeword,indexFC,&encoderObj->extraTime, (Ipp16s)subfrIdx);
                    CodewordImpConv_G729(indexFC[1],codeword,impResp,y2);

                    *pAna++ = indexFC[1];/*  index  of positions */
                    *pAna++ = indexFC[0];/*  index of signs  */

                    encoderObj->codecType = G729_CODEC;
                    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, Dn, LP_SUBFRAME_DIM, encoderObj);
                    LOCAL_ALIGN_ARRAY_FREE(32, Ipp32s, rr, CORR_DIM, encoderObj);
                    break;
                }
        }

        /* include fixed-gain pitch contribution into codeword */
        if(valOpenDelay < LP_SUBFRAME_DIM)
            ippsHarmonicFilter_16s_I(betaPreFilter,valOpenDelay,&codeword[valOpenDelay],LP_SUBFRAME_DIM-valOpenDelay);

        if(encoderObj->codecType != G729D_CODEC) {
            LOCAL_ARRAY(Ipp16s, gains, 2, encoderObj);
            LOCAL_ARRAY(Ipp16s, gInd, 2, encoderObj);
            ippsGainQuant_G729_16s(val1, y1, codeword, y2, encoderObj->prevFrameQuantEn, gains, gInd,improveFlag);
            gainPit  = gains[0];
            gainCode = gains[1];
            *pAna++ = (Ipp16s)((LUT1[gInd[0]]<<CDBK2_BIT_NUM) | LUT2[gInd[1]]);

            LOCAL_ARRAY_FREE(Ipp16s, gInd, 2, encoderObj);
            LOCAL_ARRAY_FREE(Ipp16s, gains, 2, encoderObj);
        } else {
            LOCAL_ARRAY(Ipp16s, gains, 2, encoderObj);
            LOCAL_ARRAY(Ipp16s, gInd, 2, encoderObj);
            ippsGainQuant_G729D_16s(val1,y1,codeword,y2,encoderObj->prevFrameQuantEn,gains,gInd,improveFlag);
            gainPit  = gains[0];
            gainCode = gains[1];
            *pAna++ = (Ipp16s)((LUT1_6k[gInd[0]]<<CDBK2_BIT_NUM_6K) | LUT2_6k[gInd[1]]);

            LOCAL_ARRAY_FREE(Ipp16s, gInd, 2, encoderObj);
            LOCAL_ARRAY_FREE(Ipp16s, gains, 2, encoderObj);
        }

        updateExcErr_G729(gainPit, valOpenDelay,encoderObj->coderErr);

        for(i= 0; i< 4; i++)
            encoderObj->pGain[i] = encoderObj->pGain[i+1];
        encoderObj->pGain[4] = gainPit;

        betaPreFilter = gainPit;
        if(betaPreFilter > PITCH_SHARP_MAX)  betaPreFilter = PITCH_SHARP_MAX;
        if(betaPreFilter < PITCH_SHARP_MIN)  betaPreFilter = PITCH_SHARP_MIN;

        ippsInterpolateC_NR_G729_16s_Sfs(
                                        &exc[subfrIdx],gainPit,codeword,gainCode,&exc[subfrIdx],LP_SUBFRAME_DIM,14);
        SynthesisFilter_G729_16s(ppAq,&exc[subfrIdx],&encoderObj->pSynth[subfrIdx],LP_SUBFRAME_DIM,synFltw0,BWLPCF_DIM-mAq);
        ippsSub_16s(&encoderObj->pSynth[subfrIdx+LP_SUBFRAME_DIM-BWLPCF_DIM],&PRESENT_SPEECH[subfrIdx+LP_SUBFRAME_DIM-BWLPCF_DIM],encoderObj->resFilMem/*+20*/,BWLPCF_DIM);
        m_a = BWLPCF_DIM;
        if(gainCode <= IPP_MAX_16S/2 && gainCode >= IPP_MIN_16S/2) {
            ippsInterpolateC_G729_16s_Sfs(
                                         &y1[LP_SUBFRAME_DIM-m_a],gainPit,&y2[LP_SUBFRAME_DIM-m_a],(Ipp16s)(2*gainCode),tmpvec,m_a,14);
        } else {

            for(i = 0; i < m_a; i++) {
                tmpvec[i] = (Ipp16s)(((gainPit*y1[LP_SUBFRAME_DIM-m_a+i])>>14)+((gainCode*y2[LP_SUBFRAME_DIM-m_a+i])>>13));
            }