vadg729.c

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

    {32604,  164,32440,  328,24576, BWF_HARMONIC_E},
    {32604,  164,32702,   66,24576, BWF_HARMONIC_E},
};

void VoiceActivityDetect_G729(Ipp16s *pSrc,Ipp16s *pLSF,Ipp32s *pAutoCorr,
                              Ipp16s autoExp, Ipp16s pRc, Ipp16s *pVad, Ipp8s *pVADmem,Ipp16s *pTmp) {
    Ipp32s L_tmp;
    VADmemory_Obj *vadMem =  (VADmemory_Obj*)pVADmem;
    const Ipp16s *pVadTable;

    Ipp16s frameCounter, VADPrev, VADPPrev, *LSFMean, *min_buf;
    Ipp16s vadmin,SEMean,minPrev=IPP_MAX_16S,minNext,lessCounter,updateCounter;
    Ipp16s SZCMean,SLEMean,EMean,prev_vadEner,SILcounter,v_flag,cnt_ext,cur_flag;
    Ipp16s i, j, exp, fractal;
    Ipp16s energy, energyLow, spectrDist, ZC, highBandE, lowBandE, crossZeroRate;
    Ipp32s   r0;

    r0 = pAutoCorr[0];
    for(i=0; i<= VAD_LPC_DIM ; i++)
        pTmp[i]=(Ipp16s)(pAutoCorr[i]>>16);

    VADPrev = vadMem->VADPrev;
    VADPPrev = vadMem->VADPPrev;
    LSFMean = vadMem->LSFMean;
    min_buf = vadMem->minBuf;
    vadmin = vadMem->minVAD;
    SEMean = vadMem->SEMean;
    minPrev = vadMem->minPrev;
    minNext = vadMem->minNext;
    lessCounter = vadMem->lessCounter;
    updateCounter = vadMem->updateCounter;
    SZCMean = vadMem->SZCMean;
    SLEMean = vadMem->SLEMean;
    EMean = vadMem->EMean;
    prev_vadEner = vadMem->VADPrevEnergy;
    SILcounter = vadMem->SILcounter;
    v_flag = vadMem->VADflag2;
    cnt_ext = vadMem->extCounter;
    cur_flag = vadMem->VADflag;
    frameCounter = vadMem->frameCounter;
    if(frameCounter == IPP_MAX_16S) frameCounter = 256;
    else frameCounter++;

    /* get frame energy */
    Log2_G729(r0, &exp, &fractal);
    L_tmp = (autoExp+exp)*9864 + ((fractal*9864)>>15);
    energy = (Ipp16s)(L_tmp>>4);
    energy -= 6108;

    /* get low band energy */
    ippsDotProd_16s32s_Sfs(pTmp+1,lbfCorr+1,VAD_LPC_DIM ,&L_tmp,0);
    L_tmp = 4 * L_tmp;
    L_tmp = Add_32s(L_tmp, 2 * pTmp[0] * lbfCorr[0]);
    Log2_G729(L_tmp, &exp, &fractal);
    L_tmp = (autoExp+exp)*9864 + ((fractal*9864)>>15);
    energyLow = (Ipp16s)(L_tmp>>4);
    energyLow -= 6108;

    /* calculate spectrDist */
    for(i=0, L_tmp=0; i<LPF_DIM; i++) {
        j = (Ipp16s)(pLSF[i] - LSFMean[i]);
        L_tmp += j * j;
    }
    spectrDist = (Ipp16s)(L_tmp >> 15);

    /* compute # zero crossing */
#if defined(__ICL ) && defined(_IPP_A6)
    ZC=(Ipp16s)(ownSignChangeRate_A6(pSrc+ZEROcrossBegin)*410);
#else
    ZC=(Ipp16s)(ownSignChangeRate(pSrc+ZEROcrossBegin)*410);
#endif

    if(frameCounter < 129) {
        if(energy < vadmin) {
            vadmin = energy;
            minPrev = energy;
        }

        if(0 == (frameCounter & 7)) {
            i = (Ipp16s)((frameCounter>>3) - 1);
            min_buf[i] = vadmin;
            vadmin = IPP_MAX_16S;
        }
    }

    if(0 == (frameCounter & 7)) {
        ippsMin_16s(min_buf,16,&minPrev);
    }

    if(frameCounter >= 129) {
        if((frameCounter & 7) == 1) {
            vadmin = minPrev;
            minNext = IPP_MAX_16S;
        }
        if(energy < vadmin)
            vadmin = energy;
        if(energy < minNext)
            minNext = energy;

        if(!(frameCounter & 7)) {
            for(i=0; i<15; i++)
                min_buf[i] = min_buf[i+1];
            min_buf[15] = minNext;
            ippsMin_16s(min_buf,16,&minPrev);
        }

    }

    if(frameCounter <= VADinitFrame) {
        if(energy < 3072) {
            pVad[0] = 0;
            lessCounter++;
        } else {
            pVad[0] = 1;
            EMean = (Ipp16s)(EMean + (energy>>5));
            SZCMean = (Ipp16s)(SZCMean + (ZC>>5));
            for(i=0; i<LPF_DIM; i++) {
                LSFMean[i] = (Ipp16s)(LSFMean[i] + (pLSF[i] >> 5));
            }
        }
    }

    if(frameCounter >= VADinitFrame) {
        if(VADinitFrame==frameCounter) {
            L_tmp = EMean * ifactor[lessCounter];
            EMean = (Ipp16s)(L_tmp>>ishift[lessCounter]);

            L_tmp = SZCMean * ifactor[lessCounter];
            SZCMean = (Ipp16s)(L_tmp >> ishift[lessCounter]);

            for(i=0; i<LPF_DIM; i++) {
                L_tmp = LSFMean[i] * ifactor[lessCounter];
                LSFMean[i] = (Ipp16s)(L_tmp >> ishift[lessCounter]);
            }
            SEMean = (Ipp16s)(EMean - 2048);
            SLEMean = (Ipp16s)(EMean - 2458);
        }

        highBandE = (Ipp16s)(SEMean - energy);
        lowBandE = (Ipp16s)(SLEMean - energyLow);
        crossZeroRate = (Ipp16s)(SZCMean - ZC);

        if(energy < 3072)
            pVad[0] = 0;
        else
            pVad[0] = ownMakeDecision(lowBandE, highBandE, spectrDist, crossZeroRate);

        v_flag = 0;
        if((VADPrev==1) && (pVad[0]==0) && (highBandE < -410) && (energy > 3072)) {
            pVad[0] = 1;
            v_flag = 1;
        }

        if(cur_flag == 1) {
            if((VADPPrev == 1) && (VADPrev == 1) && (pVad[0] == 0) &&
               Abs_16s((Ipp16s)(prev_vadEner - energy)) <= 614) {
                cnt_ext++;
                pVad[0] = 1;
                v_flag = 1;
                if(cnt_ext <= 4)
                    cur_flag = 1;
                else {
                    cnt_ext = cur_flag = 0;
                }
            }
        } else
            cur_flag=1;

        if(pVad[0] == 0)
            SILcounter++;

        if((pVad[0] == 1) && (SILcounter > 10)
           && (energy - prev_vadEner <= 614)) {
            pVad[0] = 0;
            SILcounter=0;
        }

        if(pVad[0] == 1)
            SILcounter=0;

        if(((energy - 614) < SEMean) && (frameCounter > 128) && (!v_flag) && (pRc < 19661))
            pVad[0] = 0;

        if(((energy - 614) < SEMean) && (pRc < 24576) && (spectrDist < 83)) {
            updateCounter++;
            if(updateCounter < 20)
                pVadTable = vadTable[0];
            else
                if(updateCounter < 30)
                    pVadTable = vadTable[1];
                else
                    if(updateCounter < 40)
                        pVadTable = vadTable[2];
                    else
                        if(updateCounter < 50)
                            pVadTable = vadTable[3];
                        else
                            if(updateCounter < 60)
                                pVadTable = vadTable[4];
                            else
                                pVadTable = vadTable[5];
            /* update means */
            L_tmp = pVadTable[0] * SEMean + pVadTable[1] * energy;
            SEMean = (Ipp16s)(L_tmp >> 15);

            L_tmp = pVadTable[0] * SLEMean + pVadTable[1] * energyLow;
            SLEMean = (Ipp16s)(L_tmp>>15);

            L_tmp = pVadTable[2] * SZCMean + pVadTable[3] * ZC;
            SZCMean = (Ipp16s)(L_tmp>>15);

            for(i=0; i<LPF_DIM; i++) {
                L_tmp = pVadTable[4] * LSFMean[i] + pVadTable[5] * pLSF[i];
                LSFMean[i] = (Ipp16s)(L_tmp>>15);
            }
        }
        if(frameCounter > 128 && ((SEMean < vadmin &&
           spectrDist < 83) || (SEMean -vadmin) > 2048)) {
            SEMean = vadmin;
            updateCounter = 0;
        }
    }
    vadMem->VADPrevEnergy = energy;
    vadMem->minVAD = vadmin;
    vadMem->SEMean = SEMean;
    vadMem->minPrev = minPrev;
    vadMem->minNext = minNext;
    vadMem->lessCounter = lessCounter;
    vadMem->updateCounter = updateCounter;
    vadMem->SZCMean = SZCMean;
    vadMem->SLEMean = SLEMean;
    vadMem->EMean = EMean;
    vadMem->SILcounter = SILcounter;
    vadMem->VADflag2 = v_flag;
    vadMem->extCounter = cnt_ext;
    vadMem->VADflag = cur_flag;
    vadMem->frameCounter = frameCounter;
}