encg729.c

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

    for(i=0; i<ACF_NOW; i++)
        encoderObj->ACFsfs[i] = 40;
    for(i=0; i<GAIN_NUM; i++)
        encoderObj->energySfs[i] = 40;
    for(i=0; i<GAIN_NUM; i++)
        encoderObj->energy[i] = 0;
    encoderObj->gainNow = 0;
    encoderObj->ACFcounter = 0;
    encoderObj->speechDiff = 0;
    return;
}
void CNG_encoder(Ipp16s *prevExcitat, Ipp16s *prevSubfrLSPquant, Ipp16s *pAq, Ipp16s *pAna,
                G729Encoder_Obj *encoderObj) {
    Ipp16s *seed = &encoderObj->seed;
    Ipp16s VADPrev = ((VADmemory_Obj*)encoderObj->vadMem)->VADPrev;
    LOCAL_ARRAY(Ipp16s, curAcf, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(Ipp32s, acfInt, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(Ipp16s, bidArr, LPF_DIM, encoderObj);
    LOCAL_ARRAY(Ipp16s, Coeff, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(Ipp16s, newLSP, LPF_DIM, encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp16s, lsp, LPF_DIM, encoderObj);
    LOCAL_ARRAY(Ipp16s, lsfSid_q, LPF_DIM, encoderObj);
    LOCAL_ARRAY(Ipp16s, s_ACFsum, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(Ipp32s, sumMem, LPF_DIM+1, encoderObj);
    Ipp16s *LPCc, energyVal, tmp1, tmp2, delay[2], foo;
    Ipp32s   i, curIgain, dist, distSfs, thresh, ACnorm = encoderObj->ACnorm;
    Ipp16s SIDframeCounter = encoderObj->SIDframeCounter;
    Ipp16s speechDiff = encoderObj->speechDiff;
    Ipp16s prevDTXEnergy = encoderObj->prevDTXEnergy;
    Ipp16s sidGain = encoderObj->sidGain;
    Ipp16s gainNow = encoderObj->gainNow;
    Ipp16s ACFcounter = encoderObj->ACFcounter;
    Ipp16s *energy = encoderObj->energy;
    Ipp16s *energySfs = encoderObj->energySfs;
    Ipp16s *pACF = encoderObj->pACF;
    Ipp16s *ACFsfs = encoderObj->ACFsfs;
    Ipp16s *reflC = encoderObj->reflC;
    Ipp16s *prevCoeff = encoderObj->prevCoeff;
    Ipp16s *quantLspSID = encoderObj->quantLspSID;
    Ipp16s *exc = prevExcitat+L_prevExcitat;
    energy[1] = energy[0]; energySfs[1] = energySfs[0];
    Sum_G729_16s_Sfs(pACF, ACFsfs, curAcf, &energySfs[0], ACF_NOW,sumMem);
    if(curAcf[0] == 0) energy[0] = 0;
    else {
        for(i=0; i<LPF_DIM+1;i++)
            acfInt[i] = curAcf[i] << 16;
        if(ippStsOverflow == ippsLevinsonDurbin_G729B(acfInt, Coeff,bidArr,energy)) {
            ippsCopy_16s(encoderObj->prevSubfrLPC,Coeff,LPF_DIM+1);
            bidArr[0] = encoderObj->prevRC[0];
            bidArr[1] = encoderObj->prevRC[1];
        } else {
            ippsCopy_16s(Coeff,encoderObj->prevSubfrLPC,LPF_DIM+1);
            encoderObj->prevRC[0] = bidArr[0];
            encoderObj->prevRC[1] = bidArr[1];
        }
    }
    /* if 1-st frame of silence => SID frame */
    if(VADPrev != 0) {
        SIDframeCounter = 0;
        pAna[0] = 2;
        encoderObj->energyDim = 1;
        QuantSIDGain_G729B_16s(energy, energySfs, encoderObj->energyDim, &energyVal, &curIgain);

    } else {
        if(encoderObj->energyDim < GAIN_NUM) encoderObj->energyDim++;
        QuantSIDGain_G729B_16s(energy, energySfs, encoderObj->energyDim, &energyVal, &curIgain);
        ippsDotProdAutoScale_16s32s_Sfs(reflC,curAcf, LPF_DIM+1, &dist, &distSfs);
        tmp1 = (Ipp16s)(ACnorm + 9);
        tmp2 = (Ipp16s)distSfs;
        tmp1 = (Ipp16s)(tmp1 - tmp2);
        thresh = energy[0] + ((energy[0] * 4855 + BWF_HARMONIC)>>15);
        if(tmp1<0)
            thresh >>= (- tmp1);
        else
            thresh <<= tmp1;
        if(dist > thresh) {
            speechDiff = 1;
        }
        if(Abs_16s((Ipp16s)(prevDTXEnergy - energyVal)) > 2)
            speechDiff = 1;
        SIDframeCounter++;
        if(SIDframeCounter < SID_FRAME_MIN) {
            pAna[0] = 0;
        } else {
            pAna[0]=(Ipp16s)((speechDiff != 0)?2:0);
            SIDframeCounter = SID_FRAME_MIN;
        }
    }
    if(pAna[0] == 2) {
        SIDframeCounter = speechDiff = 0;
        {
            /* calculate the previous average filter */
            Sum_G729_16s_Sfs(encoderObj->ACFsum, encoderObj->ACFsumSfs, s_ACFsum, &tmp1, ACF_TOTAL,sumMem);
            if(s_ACFsum[0] == 0) {
                ippsCopy_16s(presetOldA,prevCoeff,LPF_DIM+1);
            } else {
                for(i=0; i<LPF_DIM+1;i++)
                    acfInt[i] = s_ACFsum[i] << 16;
                if(ippStsOverflow == ippsLevinsonDurbin_G729B(acfInt, prevCoeff,bidArr,&tmp1)) {
                    ippsCopy_16s(encoderObj->prevSubfrLPC,prevCoeff,LPF_DIM+1);
                    bidArr[0] = encoderObj->prevRC[0];
                    bidArr[1] = encoderObj->prevRC[1];
                } else {
                    ippsCopy_16s(prevCoeff,encoderObj->prevSubfrLPC,LPF_DIM+1);
                    encoderObj->prevRC[0] = bidArr[0];
                    encoderObj->prevRC[1] = bidArr[1];
                }
            }
        }
        ippsAutoCorr_NormE_NR_16s(prevCoeff,LPF_DIM+1,reflC,LPF_DIM+1,&ACnorm);
        ippsDotProdAutoScale_16s32s_Sfs(reflC,curAcf, LPF_DIM+1, &dist, &distSfs);
        tmp1 = (Ipp16s)(ACnorm + 9);
        tmp2 = (Ipp16s)distSfs;
        tmp1 = (Ipp16s)(tmp1 - tmp2);
        thresh = energy[0] + ((energy[0] * 3161 + BWF_HARMONIC)>>15);
        if(tmp1<0)
            thresh >>= (- tmp1);
        else
            thresh <<= tmp1;

        if(dist <= thresh) {
            LPCc = prevCoeff;
        } else {
            LPCc = Coeff;
            ippsAutoCorr_NormE_NR_16s(Coeff,LPF_DIM+1,reflC,LPF_DIM+1,&ACnorm);
        }

        if(encoderObj->codecType==G729A_CODEC)
            ippsLPCToLSP_G729A_16s(LPCc, prevSubfrLSPquant, newLSP);
        else
            ippsLPCToLSP_G729_16s(LPCc, prevSubfrLSPquant, newLSP);
        ippsLSPToLSF_G729_16s(newLSP, lsp);
        if(lsp[0] < LSF_MIN)
            lsp[0] = LSF_MIN;
        for(i=0 ; i <LPF_DIM-1 ; i++)
            if((lsp[i+1] - lsp[i]) < (BW_EXP_FACT<<1))
                lsp[i+1] = (Ipp16s)(lsp[i] + (BW_EXP_FACT<<1));
        if(lsp[LPF_DIM-1] > LSF_MAX)
            lsp[LPF_DIM-1] = LSF_MAX;
        if(lsp[LPF_DIM-1] < lsp[LPF_DIM-2])
            lsp[LPF_DIM-2] = (Ipp16s)(lsp[LPF_DIM-1] - BW_EXP_FACT);
        ippsLSFQuant_G729B_16s(lsp, (Ipp16s*)(encoderObj->prevLSPfreq), lsfSid_q, &pAna[1]);

        ippsLSFToLSP_G729_16s(lsfSid_q,quantLspSID);

        prevDTXEnergy = energyVal;
        sidGain = SIDgain[curIgain];
        pAna[4] = (Ipp16s)curIgain;
    }
    if(VADPrev != 0) gainNow = sidGain;
    else {
        gainNow = (Ipp16s)(((gainNow * GAIN0) + BWF_HARMONIC) >> 15);
        gainNow = (Ipp16s)(gainNow + ((sidGain * GAIN1 + BWF_HARMONIC) >> 15));
    }

    if(gainNow == 0) {
        ippsZero_16s(exc,LP_FRAME_DIM);
        for(i = 0; i < LP_FRAME_DIM; i += LP_SUBFRAME_DIM)
            updateExcErr_G729(0, LP_SUBFRAME_DIM+1, encoderObj->coderErr);
    } else {
        for(i = 0;  i < LP_FRAME_DIM; i += LP_SUBFRAME_DIM) {
            Ipp32s invSq;
            Ipp16s Gp;
            LOCAL_ARRAY(Ipp16s, pos, 4, encoderObj);
            LOCAL_ARRAY(Ipp16s, sign, 4, encoderObj);
            LOCAL_ALIGN_ARRAY(32, Ipp16s, excg, LP_SUBFRAME_DIM, encoderObj);
            LOCAL_ARRAY(Ipp16s,tmpArray,LP_SUBFRAME_DIM, encoderObj);
            const Ipp16s *excCached;

            RandomCodebookParm_G729B_16s(seed,pos,sign,&Gp,delay);
            ippsDecodeAdaptiveVector_G729_16s_I(delay,&prevExcitat[i]);
            if(encoderObj->CNGidx > CNG_STACK_SIZE-1) { /* not cached */
                ippsRandomNoiseExcitation_G729B_16s(seed,excg,LP_SUBFRAME_DIM);
                ippsDotProd_16s32s_Sfs(excg,excg,LP_SUBFRAME_DIM,&invSq,0);
                ippsInvSqrt_32s_I(&invSq,1);
                excCached=excg;
            } else {
                *seed = cngSeedOut[encoderObj->CNGidx];
                invSq = cngInvSqrt[encoderObj->CNGidx];
                excCached=&cngCache[encoderObj->CNGidx][0];
                encoderObj->CNGidx++;
            }
            NoiseExcitationFactorization_G729B_16s(excCached,invSq,gainNow,excg,LP_SUBFRAME_DIM);
            if(ComfortNoiseExcitation_G729B_16s_I(excg,pos,sign,gainNow,Gp,&exc[i],&foo,tmpArray)<0) {
                Gp = 0;
            }
            updateExcErr_G729(Gp, delay[0], encoderObj->coderErr);
            LOCAL_ARRAY_FREE(Ipp16s,tmpArray,LP_SUBFRAME_DIM, encoderObj);
            LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, excg, LP_SUBFRAME_DIM, encoderObj);
            LOCAL_ARRAY_FREE(Ipp16s, sign, 4, encoderObj);
            LOCAL_ARRAY_FREE(Ipp16s, pos, 4, encoderObj);
        }
    }

    ippsInterpolate_G729_16s(prevSubfrLSPquant,quantLspSID,lsp,LPF_DIM);

    ippsLSPToLPC_G729_16s(lsp,&pAq[0]);
    ippsLSPToLPC_G729_16s(quantLspSID,&pAq[LPF_DIM+1]);
    ippsCopy_16s(quantLspSID,prevSubfrLSPquant,LPF_DIM);
    if(ACFcounter == 0) ACFsumUpd(encoderObj->ACFsum,encoderObj->ACFsumSfs,encoderObj->pACF,encoderObj->ACFsfs,sumMem);

    encoderObj->SIDframeCounter = SIDframeCounter;
    encoderObj->ACnorm = (Ipp16s)ACnorm;
    encoderObj->speechDiff = speechDiff;
    encoderObj->prevDTXEnergy = prevDTXEnergy;
    encoderObj->sidGain = sidGain;
    encoderObj->gainNow = gainNow;
    encoderObj->ACFcounter = ACFcounter;

    LOCAL_ARRAY_FREE(Ipp32s, sumMem, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY_FREE(Ipp16s, s_ACFsum, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY_FREE(Ipp16s, lsfSid_q, LPF_DIM, encoderObj);
    LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, lsp, LPF_DIM, encoderObj);
    LOCAL_ARRAY_FREE(Ipp16s, newLSP, LPF_DIM, encoderObj);
    LOCAL_ARRAY_FREE(Ipp16s, Coeff, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY_FREE(Ipp16s, bidArr, LPF_DIM, encoderObj);
    LOCAL_ARRAY_FREE(Ipp32s, acfInt, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY_FREE(Ipp16s, curAcf, LPF_DIM+1, encoderObj);
    return;
}

void CNG_Update( Ipp16s *pVal1, Ipp16s pVal2, Ipp16s Vad, G729Encoder_Obj *encoderObj
               ) {
    Ipp16s i,*p1,*p2;
    LOCAL_ARRAY(Ipp32s, sumMem, LPF_DIM+1, encoderObj);
    Ipp16s *pACF = encoderObj->pACF;
    Ipp16s *ACFsfs = encoderObj->ACFsfs;
    Ipp16s ACFcounter = encoderObj->ACFcounter;

    p1 = pACF + ACF_DIM - 1;
    p2 = p1 - (LPF_DIM+1);
    for(i=0; i<(ACF_DIM-(LPF_DIM+1)); i++)
        *(p1--) = *(p2--);
    for(i=ACF_NOW-1; i>=1; i--)
        ACFsfs[i] = ACFsfs[i-1];
    ACFsfs[0] = (Ipp16s)(-(16 + pVal2));
    for(i=0; i<LPF_DIM+1; i++)
        pACF[i] = pVal1[i];
    ACFcounter++;
    if(ACFcounter == ACF_NOW) {
        ACFcounter = 0;
        if(Vad != 0)
            ACFsumUpd(encoderObj->ACFsum,encoderObj->ACFsumSfs,encoderObj->pACF,encoderObj->ACFsfs, sumMem);
    }
    encoderObj->ACFcounter = ACFcounter;
    LOCAL_ARRAY_FREE(Ipp32s, sumMem, LPF_DIM+1, encoderObj);
    return;
}
G729_CODECFUN( APIG729_Status, apiG729Encoder_InitBuff,
               (G729Encoder_Obj* encoderObj, Ipp8s *buff)) {
    if(NULL==encoderObj || NULL==buff)
        return APIG729_StsBadArgErr;

    encoderObj->Mem.base = buff;
    encoderObj->Mem.CurPtr = encoderObj->Mem.base;
    encoderObj->Mem.VecPtr = (Ipp32s *)(encoderObj->Mem.base+G729_ENCODER_SCRATCH_MEMORY_SIZE);

    return APIG729_StsNoErr;
}
static void vad_update_A(Ipp16s *pAq_t, Ipp16s *pAp_t, Ipp16s *exc, Ipp16s *speechHistory, Ipp16s *val1,
                         Ipp16s *wsp,  Ipp16s *resFilMem0,  Ipp8s* synFltw);
static void vad_update_I(Ipp16s *pAq_t, Ipp16s *pAp_t, Ipp16s *exc, Ipp16s *speech, Ipp16s *val1,
                         Ipp16s *wsp,  Ipp16s *resFilMem0,  Ipp8s* synFltw,  Ipp8s* synFltw0, Ipp16s *wfact1, Ipp16s *wfact2,
                         Ipp16s *pAp1, Ipp16s *pAp2, Ipp16s *resFilMem, Ipp16s *error, Ipp16s *pSynth, Ipp16s *pGain);
static APIG729_Status G729Encode
(G729Encoder_Obj* encoderObj,const Ipp16s *src, Ipp8u* dst, G729Codec_Type codecType , Ipp32s *frametype);
static APIG729_Status G729AEncode
(G729Encoder_Obj* encoderObj,const Ipp16s *src, Ipp8u* dst, Ipp32s *frametype);
static APIG729_Status G729BaseEncode
(G729Encoder_Obj* encoderObj,const Ipp16s *src, Ipp8u* dst, Ipp32s *frametype);

G729_CODECFUN(  APIG729_Status, apiG729Encode,
                (G729Encoder_Obj* encoderObj,const Ipp16s *src, Ipp8u* dst, G729Codec_Type codecType , Ipp32s *frametype)) {
    Ipp16s baseMode, vadEnable = (Ipp16s)(encoderObj->objPrm.mode == G729Encode_VAD_Enabled);
    if(encoderObj->objPrm.codecType != G729I_CODEC) encoderObj->codecType = encoderObj->objPrm.codecType;
    else encoderObj->codecType = codecType;
    baseMode = (Ipp16s)((encoderObj->codecType == G729_CODEC)&&(vadEnable != 1));
    if(codecType==G729A_CODEC) {
        if(G729AEncode(encoderObj,src,dst,frametype) != APIG729_StsNoErr) {
            return APIG729_StsErr;
        }
    } else if(baseMode) {
        if(G729BaseEncode(encoderObj,src,dst,frametype) != APIG729_StsNoErr) {
            return APIG729_StsErr;
        }
    } else {
        if(G729Encode(encoderObj,src,dst,codecType,frametype) != APIG729_StsNoErr) {
            return APIG729_StsErr;