owng729fp.c

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

    ippsDotProd_32f(pTmp, pTmp, LPC_ORDER, &fSpectralDistortion);

    /* compute # zero crossing */
    ippsSignChangeRate_32f(&pSrc[ZC_START_INDEX], ZC_END_INDEX+1-ZC_START_INDEX, &zeroNum);
    lNumZeroCrossing = zeroNum/80;

    /* Initialize and update min energies */
    if( FrameCounter < 129 ) {
        if( fFullBandEnergy < vadState->fMinEnergy ){
            vadState->fMinEnergy = fFullBandEnergy;
            vadState->fPrevMinEnergy = fFullBandEnergy;
        }
        if( (FrameCounter % 8) == 0){
            vadState->MinimumBuff[FrameCounter/8 -1] = vadState->fMinEnergy;
            vadState->fMinEnergy = IPP_MAXABS_32F;
        }
    }
    if( (FrameCounter % 8) == 0){
        ippsMin_32f(vadState->MinimumBuff,15,&vadState->fPrevMinEnergy);
    }

    if( FrameCounter >= 129 ) {
        if( (FrameCounter % 8 ) == 1) {
            vadState->fMinEnergy = vadState->fPrevMinEnergy;
            vadState->fNextMinEnergy = IPP_MAXABS_32F;
        }
        if( fFullBandEnergy < vadState->fMinEnergy )
            vadState->fMinEnergy = fFullBandEnergy;
        if( fFullBandEnergy < vadState->fNextMinEnergy )
            vadState->fNextMinEnergy = fFullBandEnergy;
        if( (FrameCounter % 8) == 0){
            for ( i =0; i< 15; i++)
                vadState->MinimumBuff[i] = vadState->MinimumBuff[i+1];
            vadState->MinimumBuff[15]  = vadState->fNextMinEnergy;
            ippsMin_32f(vadState->MinimumBuff,16,&vadState->fPrevMinEnergy);

        }
    }

    if (FrameCounter <= END_OF_INIT){
        if( fFullBandEnergy < 21.0f){
            vadState->lLessEnergyCounter++;
            *pVad = VAD_NOISE;
        }
        else{
            *pVad = VAD_VOICE;
            vadState->fMeanEnergy = (vadState->fMeanEnergy*( (float)(FrameCounter-vadState->lLessEnergyCounter -1)) +
                fFullBandEnergy)/(float) (FrameCounter-vadState->lLessEnergyCounter);
            vadState->fMeanZeroCrossing = (vadState->fMeanZeroCrossing*( (float)(FrameCounter-vadState->lLessEnergyCounter -1)) +
                lNumZeroCrossing)/(float) (FrameCounter-vadState->lLessEnergyCounter);
            ippsInterpolateC_G729_32f(vadState->MeanLSFVec, (float)(FrameCounter-vadState->lLessEnergyCounter -1),
                                             pLSF, 1.0f, vadState->MeanLSFVec, LPC_ORDER);
            ippsMulC_32f_I(1.0f/(float) (FrameCounter-vadState->lLessEnergyCounter ), vadState->MeanLSFVec, LPC_ORDER);
        }
    }

    if (FrameCounter >= END_OF_INIT ){
        if (FrameCounter == END_OF_INIT ){
            vadState->fMeanFullBandEnergy = vadState->fMeanEnergy - 10.0f;
            vadState->fMeanLowBandEnergy = vadState->fMeanEnergy - 12.0f;
        }

        fFullBandEnergyDiff = vadState->fMeanFullBandEnergy - fFullBandEnergy;
        fLowBandEnergyDiff = vadState->fMeanLowBandEnergy - fLowBandEnergy;
        fZeroCrossingDiff = vadState->fMeanZeroCrossing - lNumZeroCrossing;

        if( fFullBandEnergy < 21.0f ){
            *pVad = VAD_NOISE;
        }
        else{
            *pVad =MakeDecision(fLowBandEnergyDiff, fFullBandEnergyDiff, fSpectralDistortion, fZeroCrossingDiff );
        }

        vadState->lVADFlag =VAD_NOISE;
        if( (prevDecision == VAD_VOICE) && (*pVad == VAD_NOISE) &&
            (fFullBandEnergy > vadState->fMeanFullBandEnergy + 2.0f) && ( fFullBandEnergy > 21.0f)){
            *pVad = VAD_VOICE;
            vadState->lVADFlag=VAD_VOICE;
        }

        if((vadState->lFVD == 1) ){
            if( (prevPrevDecision == VAD_VOICE) && (prevDecision == VAD_VOICE) &&
                (*pVad == VAD_NOISE) && (fabs(vadState->fPrevEnergy - fFullBandEnergy)<= 3.0f)){
                vadState->lSmoothingCounter++;
                *pVad = VAD_VOICE;
                vadState->lVADFlag=VAD_VOICE;
                if(vadState->lSmoothingCounter <=4)
                    vadState->lFVD =1;
                else{
                    vadState->lFVD =0;
                    vadState->lSmoothingCounter=0;
                }
            }
        }
        else
            vadState->lFVD =1;

        if(*pVad == VAD_NOISE)
            vadState->lSilenceCounter++;

        if((*pVad == VAD_VOICE) && (vadState->lSilenceCounter > 10) &&
            ((fFullBandEnergy - vadState->fPrevEnergy) <= 3.0f)){
            *pVad = VAD_NOISE;
            vadState->lSilenceCounter=0;
        }


        if(*pVad == VAD_VOICE)
            vadState->lSilenceCounter=0;

        if ((fFullBandEnergy < vadState->fMeanFullBandEnergy + 3.0f) && ( FrameCounter >128)
             &&( !vadState->lVADFlag) && (ReflectCoeff < 0.6f) )
             *pVad = VAD_NOISE;

        if ((fFullBandEnergy < vadState->fMeanFullBandEnergy + 3.0f) && (ReflectCoeff < 0.75f) && ( fSpectralDistortion < 0.002532959f)){
            vadState->lUpdateCounter++;
            i = vadState->lUpdateCounter/10;
            if(i>6) i=6;
            pVadTable = vadTable[i];
            ippsInterpolateC_G729_32f(vadState->MeanLSFVec, pVadTable[4],
                                             pLSF, (pVadTable[5]), vadState->MeanLSFVec, LPC_ORDER);
            vadState->fMeanFullBandEnergy = pVadTable[0]*vadState->fMeanFullBandEnergy+(pVadTable[1])*fFullBandEnergy;
            vadState->fMeanLowBandEnergy = pVadTable[0]*vadState->fMeanLowBandEnergy+(pVadTable[1])*fLowBandEnergy;
            vadState->fMeanZeroCrossing = pVadTable[2]*vadState->fMeanZeroCrossing+(pVadTable[3])*lNumZeroCrossing;
        }

        if((FrameCounter > 128) && ( (  vadState->fMeanFullBandEnergy < vadState->fMinEnergy )
            && ( fSpectralDistortion < 0.002532959f)) || ( vadState->fMeanFullBandEnergy > vadState->fMinEnergy + 10.0f )){
            vadState->fMeanFullBandEnergy = vadState->fMinEnergy;
            vadState->lUpdateCounter = 0;
        }
    }

    vadState->fPrevEnergy = fFullBandEnergy;
    return;
}

int TestErrorContribution_G729(int valPitchDelay, int valFracPitchDelay, float *ExcErr)
{

    int j, lTmp, l1, l2, lTaming;
    float maxErrExc;

    lTmp = (valFracPitchDelay > 0) ? (valPitchDelay+1) : valPitchDelay;

    j = lTmp - SUBFR_LEN - INTER_PITCH_LEN;
    if(j < 0) j = 0;
    l1 =  (int) (j * INV_SUBFR_LEN);

    j = lTmp + INTER_PITCH_LEN - 2;
    l2 =  (int) (j * INV_SUBFR_LEN);

    maxErrExc = -1.f;
    lTaming = 0 ;
    for(j=l2; j>=l1; j--) {
        if(ExcErr[j] > maxErrExc) maxErrExc = ExcErr[j];
    }
    if(maxErrExc > THRESH_ERR) {
        lTaming = 1;
    }
    return(lTaming);
}

void UpdateExcErr_G729(float valPitchGain, int valPitchDelay, float *pExcErr)
{
    int i, l1, l2, n;
    float fMax, fTmp;

    fMax = -1.f;

    n = valPitchDelay- SUBFR_LEN;
    if(n < 0) {
        fTmp = 1.f + valPitchGain * pExcErr[0];
        if(fTmp > fMax) fMax = fTmp;
        fTmp = 1.f + valPitchGain * fTmp;
        if(fTmp > fMax) fMax = fTmp;
    } else {
        l1 = (int) (n * INV_SUBFR_LEN);

        i = valPitchDelay - 1;
        l2 = (int) (i * INV_SUBFR_LEN);

        for(i = l1; i <= l2; i++) {
            fTmp = 1.f + valPitchGain * pExcErr[i];
            if(fTmp > fMax) fMax = fTmp;
        }
    }

    for(i=3; i>=1; i--) pExcErr[i] = pExcErr[i-1];
    pExcErr[0] = fMax;

    return;
}

void isBackwardModeDominant_G729(int *isBackwardModeDominant, int LPCMode, int *pCounterBackward, int *pCounterForward)
{

    int lTmp, lCounter;

    if (LPCMode == 0) (*pCounterForward)++;
    else (*pCounterBackward)++;

    lCounter = *pCounterBackward + *pCounterForward;

    if (lCounter == 100) {
        lCounter = lCounter >> 1;
        *pCounterBackward = (*pCounterBackward) >> 1;
        *pCounterForward = (*pCounterForward) >> 1;
    }

    *isBackwardModeDominant = 0;
    if (lCounter >= 10) {
        lTmp = (*pCounterForward) << 2;
        if (*pCounterBackward > lTmp) *isBackwardModeDominant = 1;
    }

    return;
}

float CalcEnergy_dB_G729(float *pSrc, int len)
{
   double  dEnergy;
   float fEnergydB;
   int n, k, lTmp;

   ippsDotProd_32f64f(pSrc, pSrc, len, &dEnergy);
   dEnergy += 0.0001;
   fEnergydB = (float)log10(dEnergy);
   n = (int) (fEnergydB * INVERSE_LOG2);
   if(n >= 4) {
      if(dEnergy > 2147483647.) dEnergy = 93.1814;
      else {
         k = (int)dEnergy;
         lTmp = -(1 << (n-4));
         k &= lTmp;
         dEnergy = 10. * log10((float)k);
      }
   }
   else dEnergy = 0.005;

   return (float)dEnergy;
}

void InterpolatedBackwardFilter_G729(float *pSrcDstLPCBackwardFlt, float *pSrcPrevFilter, float *pSrcDstIntCoeff)
{
    int i;
    float s1, s2;
    float *pBwdLPC;
    float fIntFactor;

    pBwdLPC = pSrcDstLPCBackwardFlt + BWD_LPC_ORDERP1;

    /* Calculate the interpolated filters  */
    fIntFactor = *pSrcDstIntCoeff - 0.1f;
    if( fIntFactor < 0) fIntFactor = 0;

    for (i=0; i<BWD_LPC_ORDERP1; i++) {
        s1 = pBwdLPC[i] * (1.f - fIntFactor);
        s2 = pSrcPrevFilter[i] * fIntFactor;
        pBwdLPC[i] = s1 + s2;
    }
    //ippsInterpolateC_G729_32f(pBwdLPC, (1.f - fIntFactor), pSrcPrevFilter, fIntFactor, pBwdLPC, BWD_LPC_ORDERP1);

    for (i=0; i<BWD_LPC_ORDERP1; i++) {
        pSrcDstLPCBackwardFlt[i] = 0.5f * (pBwdLPC[i] + pSrcPrevFilter[i]);
    }
    //ippsInterpolateC_G729_32f(pBwdLPC, 0.5f, pSrcPrevFilter, 0.5f, pBwdLPC, BWD_LPC_ORDERP1);

    *pSrcDstIntCoeff = fIntFactor;
    return;
}

/* anti-sparseness post-processing */
static __ALIGN32 CONST float ImpLow[SUBFR_LEN]={
   0.4483f, 0.3515f, 0.0387f,-0.0843f,-0.1731f, 0.2293f,-0.0011f,
   -0.0857f,-0.0928f, 0.1472f, 0.0901f,-0.2571f, 0.1155f, 0.0444f,
   0.0665f,-0.2636f, 0.2457f,-0.0642f,-0.0444f, 0.0237f, 0.0338f,
   -0.0728f, 0.0688f,-0.0111f,-0.0206f,-0.0642f, 0.1845f,-0.1734f,
   0.0327f, 0.0953f,-0.1544f, 0.1621f,-0.0711f,-0.1138f, 0.2113f,
   -0.1187f, 0.0206f,-0.0542f, 0.0009f,0.3096f
};

static __ALIGN32 CONST float ImpMiddle[SUBFR_LEN]={
   0.9239f, 0.1169f, -0.1232f, 0.0907f, -0.0320f, -0.0306f, 0.0756f,
   -0.0929f, 0.0859f, -0.0681f, 0.0535f, -0.0492f, 0.0523f, -0.0542f,
   0.0471f, -0.0308f, 0.0131f, -0.0052f, 0.0144f, -0.0386f, 0.0664f,
   -0.0826f, 0.0770f, -0.0495f, 0.0105f, 0.0252f, -0.0467f, 0.0526f,
   -0.0506f, 0.0519f, -0.0630f, 0.0807f, -0.0934f, 0.0884f, -0.0604f,
   0.0170f, 0.0238f, -0.0418f, 0.0257f, 0.0200f
};

static __ALIGN32 CONST float ImpHigh[SUBFR_LEN]={
   1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
   0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
   0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
   0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
};


void PHDGetSize(Ipp32s *pDstSize)
{
   *pDstSize = sizeof(PHDmemory);
   return;
}

void PHDInit(char *phdMem)
{
   PHDmemory *phdState = (PHDmemory *)phdMem;

   ippsZero_32f(phdState->gainMem,6);
   phdState->prevDispState = 0;
   phdState->prevCbGain = 0.;
   phdState->onset = 0;
}

void PhaseDispersionUpdate_G729D(float valPitchGain, float valCodebookGain, char *phdMem)
{
    int i;
    PHDmemory *phdState = (PHDmemory *)phdMem;

    for (i = 5; i > 0; i--) phdState->gainMem[i] = phdState->gainMem[i-1];
    phdState->gainMem[0] = valPitchGain;
    phdState->prevDispState = 2;
    phdState->prevCbGain = valCodebookGain;
    phdState->onset = 0;

    return;
}

void PhaseDispersion_G729D(float *pSrcExcSignal, float *pDstFltExcSignal, float valCodebookGain,
                           float valPitchGain, float *pSrcDstInnovation, char *phdMem,char *pExtBuff)
{
    int  i;
    PHDmemory *phdState = (PHDmemory *)phdMem;

    float *pScaledLTP;
    float *pMemory;
    int *pPos;
    int numNonZeroElem, nPulse, i1, lPos;
    int phDispState;
    const float *pTable;

    pScaledLTP = (float *)pExtBuff;
    pMemory = (float *)(pExtBuff + SUBFR_LEN*sizeof(float));
    pPos = (int *)(pMemory + SUBFR_LEN*sizeof(float));

    /* anti-sparseness post-processing */
    ippsAdaptiveCodebookContribution_G729_32f(valCodebookGain, pSrcDstInnovation, pSrcExcSignal, pScaledLTP);
    ippsCopy_32f(pSrcDstInnovation,pMemory,SUBFR_LEN);
    ippsZero_32f(pSrcDstInnovation,SUBFR_LEN);

    numNonZeroElem=0;
    for (i=0; i<SUBFR_LEN; i++) {
        if (pMemory[i])
            pPos[numNonZeroElem++] = i;
    }
    if (valPitchGain <= 0.6f) {
        phDispState = 0;
    } else if ( (valPitchGain > 0.6f) && (valPitchGain < 0.9f) ) {
        phDispState = 1;
    } else {
        phDispState = 2;
    }

    for (i = 5; i > 0; i--) {
        phdState->gainMem[i]=phdState->gainMem[i-1];
    }
    phdState->gainMem[0] = valPitchGain;

    if (valCodebookGain > 2.0f * phdState->prevCbGain)
        phdState->onset = 2;
    else {
        if (phdState->onset) phdState->onset -= 1;
    }

    i1=0;
    for (i = 0; i < 6; i++) {
        if (phdState->gainMem[i] < 0.6f) i1 += 1;
    }
    if (i1 > 2 && !phdState->onset) phDispState = 0;