owng729.c

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

#if defined(__ICL ) && defined(_IPP_A6)
static int ownSignChangeRate_A6(short *pSrc /* [ZEROcrossEnd-ZEROcrossBegin+1] */) {
    int    i,ll;
    Ipp32s sum=0;
    __m64 m1,m2,m3,m4,mmSum,left_3_zer0;
    mmSum = _mm_setzero_si64();
    left_3_zer0 = _mm_set_pi16(0,0,0,0xffff);
    i = 0;
    m1    = *(__m64*)&pSrc[i];       /* m1 = first 4 */
    for(i+=16; i<=ZEROcrossEnd-ZEROcrossBegin; i+=16) {
        m3    = *(__m64*)&pSrc[i-12];/* m3 = second 4 */
        m2    = _mm_srli_si64(m1,16);
        m4    = _mm_slli_si64(m3,48);
        m4    = _mm_or_si64(m4,m2);

        m1    = _mm_mulhi_pi16(m1,m4);
        m1    = _mm_srli_pi16(m1,15);/* get the sign bit to lowest position*/
        mmSum = _mm_add_pi16(mmSum,m1);

        m1    = *(__m64*)&pSrc[i-8]; /* m1 = third 4 */
        m2    = _mm_srli_si64(m3,16);
        m4    = _mm_slli_si64(m1,48);
        m4    = _mm_or_si64(m4,m2);

        m3    = _mm_mulhi_pi16(m3,m4);
        m3    = _mm_srli_pi16(m3,15);/* get the sign bit to lowest position*/
        mmSum = _mm_add_pi16(mmSum,m3);

        m3    = *(__m64*)&pSrc[i-4]; /* m3 = fourth 4 */
        m2    = _mm_srli_si64(m1,16);
        m4    = _mm_slli_si64(m3,48);
        m4    = _mm_or_si64(m4,m2);

        m1    = _mm_mulhi_pi16(m1,m4);
        m1    = _mm_srli_pi16(m1,15);/* get the sign bit to lowest position*/
        mmSum = _mm_add_pi16(mmSum,m1);

        m1    = *(__m64*)&pSrc[i];   /* m1 = fifth 4 */
        m2    = _mm_srli_si64(m3,16);
        m4    = _mm_slli_si64(m1,48);
        m4    = _mm_or_si64(m4,m2);

        m3  = _mm_mulhi_pi16(m3,m4);
        m3    = _mm_srli_pi16(m3,15);/* get the sign bit to lowest position*/
        mmSum = _mm_add_pi16(mmSum,m3);
    }
    /* sum the lower 4 counts to 1*/
    m1    = mmSum;
    m1    = _mm_srli_si64(m1,32);
    mmSum = _mm_add_pi16(mmSum,m1);
    m1    = mmSum;
    m1    = _mm_srli_si64(m1,16);
    mmSum = _mm_add_pi16(mmSum,m1);
    mmSum = _mm_and_si64(mmSum,left_3_zer0);
    ll    = _mm_cvtsi64_si32(mmSum);
    sum  += ll;
    _mm_empty();
    return sum;
}
#else

static int ownSignChangeRate(short *pSrc /* [ZEROcrossEnd-ZEROcrossBegin+1] */) {
    int    i;
    Ipp32s sum=0;
    for(i=1; i<=ZEROcrossEnd-ZEROcrossBegin; i++)
        sum += (pSrc[i-1] * pSrc[i] < 0);
    return sum;
}

#endif

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

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

    r0 = pAutoCorr[0];
    for(i=0; i<= VAD_LPC_DIM ; i++)
        pTmp[i]=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 = 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 = L_tmp>>4;
    energyLow -= 6108;

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

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

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

        if(0 == (frameCounter & 7)) {
            i = (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 += energy>>5;
            SZCMean += ZC>>5;
            for(i=0; i<LPF_DIM; i++) {
                LSFMean[i] += pLSF[i] >> 5;
            }
        }
    }

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

            L_tmp = SZCMean * ifactor[lessCounter];
            SZCMean = L_tmp >> ishift[lessCounter];

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

        highBandE = SEMean - energy;
        lowBandE = SLEMean - energyLow;
        crossZeroRate = 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(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 = L_tmp >> 15;

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

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

            for(i=0; i<LPF_DIM; i++) {
                L_tmp = pVadTable[4] * LSFMean[i] + pVadTable[5] * pLSF[i];
                LSFMean[i] = 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;
}
void VADMusicDetection(G729Codec_Type codecType,int autoCorr,short expAutoCorr,short *pRc,
                       short *lags, short *pgains,short stat_flg,short *Vad,char* pVADmem) {
    short i, j, exp, fractal, tmp, tmp1, tmp2, tmp3, flag1, flag2, flag,
            pderr=IPP_MAX_16S, logE , spectrDist, threshold;
    int   L_tmp;
    VADmemory *vadMem = (VADmemory*)pVADmem;
    for(i=0; i<4; i++) {
        j = (pRc[i] * pRc[i])>>15;
        j = IPP_MAX_16S - j;
        pderr = (pderr * j)>>15;
    }
    L_tmp = 2*(autoCorr>>16)*pderr + 2*((((autoCorr>>1)&0x7fff)*pderr)>>15);
    Log2_G729(L_tmp, &exp, &fractal);
    L_tmp = 9864*exp + ((fractal*9864)>>15);
    i = expAutoCorr - 2;
    L_tmp += 9864 * i;
    L_tmp = ShiftL_32s(L_tmp,12);
    logE = (L_tmp>>16) - 4875;
    L_tmp = 0;
    for(i=0; i<10; i++) {
        j = vadMem->musicRC[i] - pRc[i];
        L_tmp += j * j;
    }
    if(L_tmp > IPP_MAX_32S/2)
        spectrDist = IPP_MAX_32S >> 16;
    else
        spectrDist = L_tmp>>15;
    if( *Vad == 0 ) {
        for(i=0; i<10; i++) {
            L_tmp = COEFF1 * vadMem->musicRC[i];
            L_tmp += PITCH_SHARP_MIN * pRc[i];
            vadMem->musicRC[i] = L_tmp>>15;
        }
        L_tmp = COEFF1 * vadMem->musicSEMean;
        L_tmp += PITCH_SHARP_MIN * logE;
        vadMem->musicSEMean = L_tmp>>15;
    }
    /* flag determination */
    tmp3=L_tmp=0;
    for(i=0; i<5; i++) {
        L_tmp += pgains[i] * 6554;
        tmp3 += lags[i];
    }
    L_tmp = (L_tmp>>15) * 6554;
    L_tmp += vadMem->MeanPgain * 26214;
    vadMem->MeanPgain = L_tmp>>15;
    L_tmp = 0;
    for(i=0; i<5; i++) {
        j = lags[i] << 2;
        j += lags[i];
        j -= tmp3;
        L_tmp += j * j;
    }
    if(L_tmp > 256)
        tmp2 = IPP_MAX_32S>>16;
    else
        tmp2 = L_tmp<<7;
    if( codecType == G729D_CODEC)
        threshold = 11960;
    else
        threshold = 10322;
    if(vadMem->MeanPgain > threshold)
        flag2 =1;
    else
        flag2 =0;
    if( (tmp2 < 21632)  && (vadMem->MeanPgain > 7373))
        flag1 =1;
    else
        flag1 =0;
    flag= ( (vadMem->VADPrev & (flag1 | flag2))| (flag2));
    if( (pRc[1] <= 14746) && (pRc[1] >= 0) && (vadMem->MeanPgain < BWF_HARMONIC_E))
        vadMem->conscCounterFlagR++;
    else
        vadMem->conscCounterFlagR =0;
    if( (stat_flg == 1) && (*Vad == 1))
        vadMem->musicCounter += 256;
    if( (vadMem->frameCounter & 0x003f) == 0) {
        if( vadMem->frameCounter == 64)
            vadMem->musicMCounter = vadMem->musicCounter;
        else {
            L_tmp = COEFF1 * vadMem->musicMCounter;
            L_tmp += PITCH_SHARP_MIN * vadMem->musicCounter;
            vadMem->musicMCounter = L_tmp>>15;
        }
    }
    if( vadMem->musicCounter == 0)
        vadMem->conscCounter++;
    else
        vadMem->conscCounter = 0;
    if(  ((vadMem->conscCounter > 500) || (vadMem->conscCounterFlagR > 150))) vadMem->musicMCounter = 0;

    if( (vadMem->frameCounter & 0x003f) == 0) {
        vadMem->musicCounter = 0;
    }

    if( flag== 1 )
        vadMem->count_pflag += 256;

    if( (vadMem->frameCounter & 0x003f) == 0) {
        if( vadMem->frameCounter == 64)
            vadMem->Mcount_pflag = vadMem->count_pflag;
        else {
            if(vadMem->count_pflag > 6400) {
                tmp1 = N0_98;
                tmp = 655;
            } else
                if(vadMem->count_pflag > 5120) {
                tmp1 = 31130;
                tmp = 1638;
            } else {
                tmp1 = COEFF1;
                tmp = PITCH_SHARP_MIN;
            }
            L_tmp = tmp1 * vadMem->Mcount_pflag;
            L_tmp += tmp * vadMem->count_pflag;
            vadMem->Mcount_pflag = L_tmp>>15;
        }
    }
    if( vadMem->count_pflag == 0)
        vadMem->conscCounterFlagP++;
    else
        vadMem->conscCounterFlagP = 0;

    if(((vadMem->conscCounterFlagP > 100) || (vadMem->conscCounterFlagR > 150))) vadMem->Mcount_pflag = 0;


    if( (vadMem->frameCounter & 0x003f) == 0)
        vadMem->count_pflag = 0;

    if(codecType == G729E_CODEC) {
        if( (spectrDist > 4915) && (logE > (vadMem->musicSEMean + 819)) && (vadMem->VADPrevEnergy > 10240) )
            *Vad =1;
        else if( ((spectrDist > 12452) || (logE > (vadMem->musicSEMean + 819))) &&
                 (vadMem->VADPrevEnergy > 10240) )
            *Vad =1;
        else if( ( (vadMem->Mcount_pflag > 2560) || (vadMem->musicMCounter > 280) || (vadMem->frameCounter < 64))
                 && (vadMem->VADPrevEnergy > 1433))