decg729.c

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

    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, LPCnum, LPF_DIM+1,decoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, LTPsignalBuf,LP_SUBFRAME_DIM+1+LPF_DIM,decoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s,y, IMP_RESP_LEN,decoderObj);

    return;
}

void Post_G729AB(Ipp16s delayVal, Ipp16s subfrIdx, const Ipp16s *srcLPC, Ipp16s *syn_pst,
                Ipp16s ftype, G729Decoder_Obj *decoderObj) {
    Ipp16s *iirdl = ((SynthesisFilterState*)decoderObj->synFltw0)->buffer;
    Ipp16s *preemphFilt = &decoderObj->preemphFilt;
    LOCAL_ALIGN_ARRAY(32, Ipp16s,sndLPC,2*(LPF_DIM+1), decoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, prevResidual, LP_SUBFRAME_DIM+8, decoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, prevBuf, LP_SUBFRAME_DIM+LPF_DIM, decoderObj);
    Ipp16s *prevResidual2 = prevResidual+8;
    Ipp16s *pst = prevBuf+LPF_DIM;

    ippsMul_NR_16s_Sfs(g729gammaFac2_pst,srcLPC, decoderObj->zeroPostFiltVec1, LPF_DIM+1,15);
    ippsMul_NR_16s_Sfs(g729gammaFac2_pst,srcLPC, sndLPC, LPF_DIM+1,15);
    ippsMul_NR_16s_Sfs(g729gammaFac1_pst,srcLPC, sndLPC+LPF_DIM+1,LPF_DIM+1,15);

    ippsLongTermPostFilter_G729A_16s(delayVal,&decoderObj->LTPostFilt[LPF_DIM+subfrIdx],
                                     sndLPC,decoderObj->resFilBuf1-LPF_DIM-1,prevResidual2);
    ippsMove_16s(&decoderObj->resFilBuf1[LP_SUBFRAME_DIM], &decoderObj->resFilBuf1[0], MAX_PITCH_LAG);
    if(3 != ftype)
        ippsCopy_16s(decoderObj->resFilBuf1 + MAX_PITCH_LAG,prevResidual2,LP_SUBFRAME_DIM);
    prevResidual2[-1] = *preemphFilt;
    *preemphFilt = prevResidual2[LP_SUBFRAME_DIM-1];

    ippsTiltCompensation_G729A_16s(sndLPC,prevResidual2);

    ippsCopy_16s(iirdl,pst-LPF_DIM, LPF_DIM );
    ippsShortTermPostFilter_G729A_16s(sndLPC+LPF_DIM+1, prevResidual2,pst);
    ippsCopy_16s((pst+LP_SUBFRAME_DIM-LPF_DIM), iirdl, LPF_DIM );
    ippsCopy_16s(pst,syn_pst,LP_SUBFRAME_DIM);

    ippsGainControl_G729A_16s_I(&decoderObj->LTPostFilt[LPF_DIM+subfrIdx], syn_pst, &decoderObj->gainExact);

    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, prevBuf,LP_SUBFRAME_DIM+LPF_DIM,decoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, prevResidual, LP_SUBFRAME_DIM+8,decoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, sndLPC, 2*(LPF_DIM+1),decoderObj);
}

void Post_G729I( Ipp16s delayVal, Ipp16s subfrIdx, const Ipp16s *srcLPC, Ipp16s *dstSignal,
               Ipp16s *voiceFlag, Ipp16s L_hSt, Ipp16s prevM, Ipp16s fType,
               G729Decoder_Obj *decoderObj){
    Ipp16s bwf1 = decoderObj->gammaPost1;
    Ipp16s bwf2 = decoderObj->gammaPost2;
    Ipp16s gamma_harm = decoderObj->gammaHarm;
    LOCAL_ARRAY(Ipp32s,irACF,2, decoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s,y, IMP_RESP_LEN_E, decoderObj);
    LOCAL_ALIGN_ARRAY(32,Ipp16s, LTPsignal, LP_SUBFRAME_DIM+1, decoderObj);
    LOCAL_ALIGN_ARRAY(32,Ipp16s, LPCdenom, BWLPCF1_DIM, decoderObj);
    LOCAL_ALIGN_ARRAY(32,Ipp16s, LPCnum, IMP_RESP_LEN_E, decoderObj);
    Ipp16s tmp, g0Val, temp, ACFval0, ACFval1;
    Ipp16s *iirdl = ((SynthesisFilterState*)decoderObj->synFltw0)->buffer;
    Ipp32s L_g0Val, normVal = 0, status = 0;
    const Ipp16s *signal_ptr = &decoderObj->LTPostFilt[SYNTH_BWD_DIM+subfrIdx];
    irACF[0] = irACF[1] = 0;
    ippsZero_16s(LPCnum, IMP_RESP_LEN_E);

    ippsMulPowerC_NR_16s_Sfs(srcLPC,bwf1, LPCdenom,prevM+1,15);
    ippsMulPowerC_NR_16s_Sfs(srcLPC,bwf2, LPCnum,prevM+1,15);
    ippsResidualFilter_G729E_16s(LPCnum, prevM,(Ipp16s *)signal_ptr, &decoderObj->resFilBuf1[RES_FIL_DIM], LP_SUBFRAME_DIM);
    if(fType > 1)
        ippsLongTermPostFilter_G729_16s(gamma_harm,delayVal, &decoderObj->resFilBuf1[RES_FIL_DIM],
                                        LTPsignal + 1, voiceFlag);
    else {
        *voiceFlag = 0;
        ippsCopy_16s(&decoderObj->resFilBuf1[RES_FIL_DIM], LTPsignal + 1, LP_SUBFRAME_DIM);
    }

    LTPsignal[0] = decoderObj->preemphFilt;
    ippsSynthesisFilter_G729E_16s(LPCdenom, prevM,LPCnum,y, L_hSt, &decoderObj->zeroPostFiltVec1[LPF_DIM+1]);
    status = ippsAutoCorr_NormE_16s32s(y,L_hSt,irACF,2,&normVal);
    ACFval0   = (Ipp16s)(irACF[0]>>16);
    ACFval1  = (Ipp16s)(irACF[1]>>16);
    if( ACFval0 < Abs_16s(ACFval1) || status) {
        tmp = 0;
    } else {
        tmp = (Ipp16s)((Abs_16s(ACFval1)<<15)/ACFval0);
        if(ACFval1 > 0) {
            tmp = (Ipp16s)(-tmp);
        }
    }
    ippsAbs_16s_I(y,L_hSt);
    ippsSum_16s32s_Sfs(y,L_hSt,&L_g0Val,0);
    g0Val = (Ipp16s)(ShiftL_32s(L_g0Val, 14)>>16);
    if(g0Val > 1024) {
        temp = (Ipp16s)((1024<<15)/g0Val);
        ippsMulC_NR_16s_ISfs(temp,LTPsignal + 1,LP_SUBFRAME_DIM,15);
    }
    ippsSynthesisFilter_G729E_16s_I(LPCdenom,prevM,LTPsignal + 1, LP_SUBFRAME_DIM,&iirdl[BWLPCF_DIM-prevM]);
    decoderObj->preemphFilt = LTPsignal[LP_SUBFRAME_DIM];
    ippsCopy_16s(&LTPsignal[LP_SUBFRAME_DIM-BWLPCF_DIM+1], iirdl, BWLPCF_DIM);

    ippsTiltCompensation_G729E_16s(tmp,LTPsignal, dstSignal);

    ippsGainControl_G729_16s_I(signal_ptr, dstSignal, &decoderObj->gainExact);

    ippsMove_16s(&decoderObj->resFilBuf1[LP_SUBFRAME_DIM], &decoderObj->resFilBuf1[0], RES_FIL_DIM);

    LOCAL_ALIGN_ARRAY_FREE(32,Ipp16s, LPCnum, IMP_RESP_LEN_E, decoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32,Ipp16s, LPCdenom, BWLPCF1_DIM, decoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, LTPsignal,LP_SUBFRAME_DIM+1,decoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s,y, IMP_RESP_LEN_E,decoderObj);
    LOCAL_ARRAY_FREE(Ipp32s, irACF, 2,decoderObj);
    return;
}

APIG729_Status G729ADecode
(G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst) {

    LOCAL_ALIGN_ARRAY(32, Ipp16s, AzDec, (LPF_DIM+1)*2,decoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, newLSP,LPF_DIM,decoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, ACELPcodeVec, LP_SUBFRAME_DIM,decoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, FWDfiltLPC, 2*LPF_DIM+2,decoderObj);
    LOCAL_ARRAY(Ipp16s, prevFrameDelay,2,decoderObj);
    LOCAL_ARRAY(Ipp16s, idx,4,decoderObj);
    LOCAL_ARRAY(Ipp16s, delayVal,2,decoderObj);
    Ipp16s *pAz, *pA, *ppAz, temp;
    Ipp8s *synFltw = decoderObj->synFltw;
    Ipp16s *prevExcitat = decoderObj->prevExcitat;
    Ipp16s *excitation = prevExcitat + L_prevExcitat;
    Ipp16s *synth = decoderObj->LTPostFilt+LPF_DIM;
    Ipp16s *prevSubfrLSP = decoderObj->prevSubfrLSP;
    const Ipp8u *pParm;
    const Ipp16s *parm;
    Ipp16s sidGain = decoderObj->sidGain;
    Ipp16s gainNow = decoderObj->gainNow;
    Ipp16s *lspSID = decoderObj->lspSID;
    Ipp32s   i, j, subfrIdx, index2, fType;
    Ipp16s badFrameIndicator, badPitch, index, pulseSign;

    if(NULL==decoderObj || NULL==src || NULL ==dst)
        return APIG729_StsBadArgErr;
    if(decoderObj->objPrm.objSize <= 0)
        return APIG729_StsNotInitialized;
    if(DEC_KEY != decoderObj->objPrm.key)
        return APIG729_StsBadCodecType;

    delayVal[0]=delayVal[1]=0;
    pA = AzDec;
    pParm = src;

    if(frametype == -1) {
        decoderObj->decPrm[1] = 0;
        decoderObj->decPrm[0] = 1;
    } else if(frametype == 0) {
        decoderObj->decPrm[1] = 0;
        decoderObj->decPrm[0] = 0;
    } else if(frametype == 1 || frametype == 5) {
        decoderObj->decPrm[1] = 1;
        decoderObj->decPrm[0] = 0;
        i=0;
        decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1);
        decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,5);
        decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,4);
        decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,5);
    } else if(frametype == 3) {
        i=0;
        decoderObj->decPrm[1] = 3;
        decoderObj->decPrm[0] = 0;
        decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1+FIR_STAGE_BITS);
        decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,SEC_STAGE_BITS*2);
        decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,8);
        decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,1);
        decoderObj->decPrm[1+5] = ExtractBitsG729(&pParm,&i,13);
        decoderObj->decPrm[1+6] = ExtractBitsG729(&pParm,&i,4);
        decoderObj->decPrm[1+7] = ExtractBitsG729(&pParm,&i,7);
        decoderObj->decPrm[1+8] = ExtractBitsG729(&pParm,&i,5);
        decoderObj->decPrm[1+9] = ExtractBitsG729(&pParm,&i,13);
        decoderObj->decPrm[1+10] = ExtractBitsG729(&pParm,&i,4);
        decoderObj->decPrm[1+11] = ExtractBitsG729(&pParm,&i,7);
        decoderObj->decPrm[1+4] = (Ipp16s)((equality(decoderObj->decPrm[1+3])+decoderObj->decPrm[1+4]) & 0x00000001); /*  parity error (1) */
    }

    parm = decoderObj->decPrm;

    badFrameIndicator = *parm++;
    fType = *parm;
    if(badFrameIndicator == 1) {
        fType = decoderObj->CNGvar;
        if(fType == 1) fType = 0;
    }

    ippsMove_16s(&decoderObj->LTPostFilt[LP_FRAME_DIM], &decoderObj->LTPostFilt[0], LPF_DIM );

    if(fType < 2) {
        if(fType == 1) {
            LOCAL_ALIGN_ARRAY(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
            sidGain = SIDgain[(Ipp32s)parm[4]];
            ippsLSFDecode_G729B_16s(&parm[1],(Ipp16s*)(decoderObj->prevLSPfreq),lsfq);
            ippsLSFToLSP_G729_16s(lsfq,lspSID);
            LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
        } else {
            if(decoderObj->CNGvar > 1) {
                QuantSIDGain_G729B_16s(&decoderObj->SIDflag0, &decoderObj->SIDflag1, 0, &temp, &index2);
                sidGain = SIDgain[(Ipp32s)index2];
            }
        }
        if(decoderObj->CNGvar > 1 || frametype == 5) {
            gainNow = sidGain;
        } else {
            gainNow = (Ipp16s)((gainNow * GAIN0 + BWF_HARMONIC)>>15);
            gainNow = Add_16s(gainNow, (Ipp16s)((sidGain * GAIN1 + BWF_HARMONIC)>>15));
        }

        if(gainNow == 0) ippsZero_16s(excitation,LP_FRAME_DIM);
        else {
            for(i = 0;  i < LP_FRAME_DIM; i += LP_SUBFRAME_DIM) {
                Ipp32s invSq;
                Ipp16s pG2;
                Ipp16s g;
                const Ipp16s *excCached;
                LOCAL_ARRAY(Ipp16s, tmpIdxVec, 4, decoderObj);
                LOCAL_ARRAY(Ipp16s, pulsesSigns, 4, decoderObj);
                LOCAL_ALIGN_ARRAY(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
                LOCAL_ARRAY(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);

                RandomCodebookParm_G729B_16s(&decoderObj->seed,tmpIdxVec,pulsesSigns,&pG2,delayVal);
                ippsDecodeAdaptiveVector_G729_16s_I(delayVal,&prevExcitat[i]);
                if(decoderObj->CNGidx > CNG_STACK_SIZE-1) { /* not cached */
                    ippsRandomNoiseExcitation_G729B_16s(&decoderObj->seed,excg,LP_SUBFRAME_DIM);
                    ippsDotProd_16s32s_Sfs(excg,excg,LP_SUBFRAME_DIM,&invSq,0);
                    ippsInvSqrt_32s_I(&invSq,1);  /* Q30 */
                    excCached=excg;
                } else {
                    decoderObj->seed = cngSeedOut[decoderObj->CNGidx];
                    invSq = cngInvSqrt[decoderObj->CNGidx];
                    excCached=&cngCache[decoderObj->CNGidx][0];
                    decoderObj->CNGidx++;
                }
                NoiseExcitationFactorization_G729B_16s(excCached,invSq,gainNow,excg,LP_SUBFRAME_DIM);
                ComfortNoiseExcitation_G729B_16s_I(excg,tmpIdxVec,pulsesSigns,gainNow,pG2,&excitation[i],&g,tempArray);

                LOCAL_ARRAY_FREE(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);
                LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
                LOCAL_ARRAY_FREE(Ipp16s, pulsesSigns, 4, decoderObj);
                LOCAL_ARRAY_FREE(Ipp16s, tmpIdxVec, 4, decoderObj);
            }
        }
        ippsInterpolate_G729_16s(prevSubfrLSP,lspSID,prevSubfrLSP, LPF_DIM );
        ippsLSPToLPC_G729_16s(prevSubfrLSP,&FWDfiltLPC[0]);
        ippsLSPToLPC_G729_16s(lspSID,&FWDfiltLPC[LPF_DIM+1]);
        ippsCopy_16s(lspSID, prevSubfrLSP, LPF_DIM );
        decoderObj->sidGain = sidGain;
        decoderObj->gainNow = gainNow;

        ppAz = FWDfiltLPC;
        for(subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {
            if(ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx], LP_SUBFRAME_DIM, 12,
                                              ((SynthesisFilterState*)synFltw)->buffer)==ippStsOverflow) {
                ippsRShiftC_16s_I(2,prevExcitat,L_prevExcitat+LP_FRAME_DIM);
                ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,12,
                                               ((SynthesisFilterState*)synFltw)->buffer);
            }
            ippsCopy_16s((&synth[subfrIdx]+LP_SUBFRAME_DIM-LPF_DIM), ((SynthesisFilterState*)synFltw)->buffer, LPF_DIM );

            ppAz += LPF_DIM+1;
            prevFrameDelay[subfrIdx/LP_SUBFRAME_DIM] = decoderObj->prevFrameDelay;
        }
        decoderObj->betaPreFilter = PITCH_SHARP_MIN;

    } else {
        LOCAL_ARRAY(Ipp16s, qIndex,4,decoderObj);
        decoderObj->seed = SEED_INIT;
        decoderObj->CNGidx = 0;
        parm++;

        qIndex[0] = (Ipp16s)((parm[0] >> FIR_STAGE_BITS) & 1);
        qIndex[1] = (Ipp16s)(parm[0] & (FIR_STAGE - 1));
        qIndex[2] = (Ipp16s)((parm[1] >> SEC_STAGE_BITS) & (SEC_STAGE - 1));
        qIndex[3] = (Ipp16s)(parm[1] & (SEC_STAGE - 1));
        if(!badFrameIndicator) {
            decoderObj->prevMA = qIndex[0];
            ippsLSFDecode_G729_16s( qIndex, (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
        } else {
            ippsLSFDecodeErased_G729_16s( decoderObj->prevMA,
                                          (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
        }

        ippsLSFToLSP_G72