encg729.c

G.711,G.723.1,G.726,G.729,GSM CODEC C/C++ code

    encoderObj->gainNow = 0;
    encoderObj->ACFcounter = 0;
    encoderObj->speechDiff = 0;
    return;
}
void CNG_encoder(short *prevExcitat, short *prevSubfrLSPquant, short *pAq, short *pAna,
                G729Encoder_Obj *encoderObj) {
    short *seed = &encoderObj->seed;
    short VADPrev = ((VADmemory*)encoderObj->vadMem)->VADPrev;
    LOCAL_ARRAY(short, curAcf, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(int, acfInt, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(short, bidArr, LPF_DIM, encoderObj);
    LOCAL_ARRAY(short, Coeff, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(short, newLSP, LPF_DIM, encoderObj);
    LOCAL_ALIGN_ARRAY(32, short, lsp, LPF_DIM, encoderObj);
    LOCAL_ARRAY(short, lsfSid_q, LPF_DIM, encoderObj);
    LOCAL_ARRAY(short, s_ACFsum, LPF_DIM+1, encoderObj);
    LOCAL_ARRAY(int, sumMem, LPF_DIM+1, encoderObj);
    short *LPCc, energyVal, tmp1, tmp2, delay[2], foo;
    int   i, curIgain, dist, distSfs, thresh, ACnorm = encoderObj->ACnorm;
    short SIDframeCounter = encoderObj->SIDframeCounter;
    short speechDiff = encoderObj->speechDiff;
    short prevDTXEnergy = encoderObj->prevDTXEnergy;
    short sidGain = encoderObj->sidGain;
    short gainNow = encoderObj->gainNow;
    short ACFcounter = encoderObj->ACFcounter;
    short *energy = encoderObj->energy;
    short *energySfs = encoderObj->energySfs;
    short *pACF = encoderObj->pACF;
    short *ACFsfs = encoderObj->ACFsfs;
    short *reflC = encoderObj->reflC;
    short *prevCoeff = encoderObj->prevCoeff;
    short *quantLspSID = encoderObj->quantLspSID;
    short *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 = ACnorm + 9;
        tmp2 = distSfs;
        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(prevDTXEnergy - energyVal) > 2)
            speechDiff = 1;
        SIDframeCounter++;
        if(SIDframeCounter < SID_FRAME_MIN) {
            pAna[0] = 0;
        } else {
            pAna[0]=(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 = ACnorm + 9;
        tmp2 = distSfs;
        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] = 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] = 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] = curIgain;
    }
    if(VADPrev != 0) gainNow = sidGain;
    else {
        gainNow = ((gainNow * GAIN0) + BWF_HARMONIC) >> 15;
        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) {
            int 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 short *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 = ACnorm;
    encoderObj->speechDiff = speechDiff;
    encoderObj->prevDTXEnergy = prevDTXEnergy;
    encoderObj->sidGain = sidGain;
    encoderObj->gainNow = gainNow;
    encoderObj->ACFcounter = ACFcounter;

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

void CNG_Update( short *pVal1, short pVal2, short Vad, G729Encoder_Obj *encoderObj
               ) {
    short i,*p1,*p2;
    LOCAL_ARRAY(int, sumMem, LPF_DIM+1, encoderObj);
    short *pACF = encoderObj->pACF;
    short *ACFsfs = encoderObj->ACFsfs;
    short 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] = -(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(int, sumMem, LPF_DIM+1, encoderObj);
    return;
}
G729_CODECFUN( APIG729_Status, apiG729Encoder_InitBuff,
               (G729Encoder_Obj* encoderObj, char *buff)) {
#if !defined (NO_SCRATCH_MEMORY_USED)
    if(NULL==encoderObj || NULL==buff)
        return APIG729_StsBadArgErr;
    encoderObj->Mem.base = buff;
    encoderObj->Mem.CurPtr = encoderObj->Mem.base;
    encoderObj->Mem.VecPtr = (int *)(encoderObj->Mem.base+G729_ENCODER_SCRATCH_MEMORY_SIZE);
#endif
    return APIG729_StsNoErr;
}
static void vad_update_A(short *pAq_t, short *pAp_t, short *exc, short *speechHistory, short *val1,
                         short *wsp,  short *resFilMem0,  char* synFltw);
static void vad_update_I(short *pAq_t, short *pAp_t, short *exc, short *speech, short *val1,
                         short *wsp,  short *resFilMem0,  char* synFltw,  char* synFltw0, short *wfact1, short *wfact2,
                         short *pAp1, short *pAp2, short *resFilMem, short *error, short *pSynth, short *pGain);
static APIG729_Status G729Encode
(G729Encoder_Obj* encoderObj,const short *src, unsigned char* dst, G729Codec_Type codecType , int *frametype);
static APIG729_Status G729AEncode
(G729Encoder_Obj* encoderObj,const short *src, unsigned char* dst, int *frametype);
static APIG729_Status G729BaseEncode
(G729Encoder_Obj* encoderObj,const short *src, unsigned char* dst, int *frametype);

G729_CODECFUN(  APIG729_Status, apiG729Encode,
                (G729Encoder_Obj* encoderObj,const short *src, unsigned char* dst, G729Codec_Type codecType , int *frametype)) {
    short  baseMode, vadEnable = (encoderObj->objPrm.mode == G729Encode_VAD_Enabled);
    if(encoderObj->objPrm.codecType != G729I_CODEC) encoderObj->codecType = encoderObj->objPrm.codecType;
    else encoderObj->codecType = codecType;
    baseMode = (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;
        }
    }
    return APIG729_StsNoErr;
}

APIG729_Status G729Encode