encg729fp.c

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

    LOCAL_ALIGN_ARRAY(32, Ipp32f, forwardQntLPC, LPC_ORDERP1*2,encoderObj);    /* A(z) forward quantized for the 2 subframes */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, backwardLPC, 2*BWD_LPC_ORDERP1,encoderObj);  /* A(z) backward for the 2 subframes */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, WeightedLPC1, BWD_LPC_ORDERP1,encoderObj);        /* A(z) with spectral expansion         */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, WeightedLPC2, BWD_LPC_ORDERP1,encoderObj);        /* A(z) with spectral expansion         */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, CurrLSP, LPC_ORDER,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp32f, tmpLSP, LPC_ORDER,encoderObj);
    LOCAL_ALIGN_ARRAY(32, Ipp32f, CurrQntLSP, LPC_ORDER,encoderObj);        /* LSPs at 2th subframe                 */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, TmpAlignVec, WINDOW_LEN,encoderObj);
    /* Other vectors */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, ImpulseResponse, SUBFR_LEN,encoderObj);    /* Impulse response*/
    LOCAL_ALIGN_ARRAY(32, Ipp32f, TargetVector, SUBFR_LEN,encoderObj);    /* Target vector for pitch search     */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, FltTargetVector, SUBFR_LEN,encoderObj);   /* Target vector for codebook search  */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, FixedCodebookExc, SUBFR_LEN,encoderObj);  /* Fixed codebook excitation          */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, FltAdaptExc, SUBFR_LEN,encoderObj);    /* Filtered adaptive excitation       */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, FltFixedCodebookExc, SUBFR_LEN,encoderObj);    /* Filtered fixed codebook excitation */
    LOCAL_ALIGN_ARRAY(32, Ipp32f, PitchPredResidual, SUBFR_LEN,encoderObj);  /* Pitch prediction residual          */

   LOCAL_ARRAY(Ipp32f, forwardReflectCoeff, LPC_ORDER,encoderObj);  /* Reflection coefficients : forward analysis */
   LOCAL_ARRAY(Ipp32f, InterpolatedLSF, LPC_ORDER,encoderObj);  /* Interpolated LSF 1st subframe.       */
   LOCAL_ARRAY(Ipp32f, CurrLSF, LPC_ORDER,encoderObj);
   LOCAL_ARRAY(Ipp32f, CurrFreq, LPC_ORDER,encoderObj);
   LOCAL_ARRAY(Ipp32f, TmpAutoCorr, LPC_ORDERP1,encoderObj);
   LOCAL_ARRAY(Ipp32s,   EncodedParams, 19,encoderObj);
   LOCAL_ARRAY(Ipp32f, g_coeff, 5,encoderObj); /* Correlations between TargetVector, FltAdaptExc, & FltFixedCodebookExc:
                                             <FltAdaptExc,FltAdaptExc>, <TargetVector,FltAdaptExc>, <FltFixedCodebookExc,FltFixedCodebookExc>, <TargetVector,FltFixedCodebookExc>,<FltAdaptExc,FltFixedCodebookExc>*/
   LOCAL_ARRAY(Ipp32f, gamma1, 2,encoderObj); /* Weighting factor for the 2 subframes */
   LOCAL_ARRAY(Ipp32f, gamma2, 2,encoderObj);
   LOCAL_ARRAY(Ipp32s, code_lsp, 2,encoderObj);
   LOCAL_ARRAY(Ipp32s, delayLine, 2,encoderObj);

   Ipp32f *SpeechWnd, *pWindow;
   Ipp32f *newSpeech;                       /* Global variable */
   /* Weighted speech vector */
   Ipp32f *WeightedSpeech;
   /* Excitation vector */
   Ipp32f *Excitation;
   /* Zero vector */
   Ipp32f *pZero=NULL;
   Ipp32f *pError=NULL;
   Ipp32f *pSynth=NULL;
   Ipp32f *pQLPC;
   Ipp32f *pUnQLPC;
   Ipp32f *pLPC, *pQntLPC;

   /* Scalars */
   Ipp32s LPCMode;                  /* LP Backward (1) / Forward (0) Indication mode */
   Ipp32s apLen, aqLen;
   Ipp32s   i, j, NGamma, NSbfr;
   Ipp32s   openLoopPitch, pitchDelay, minPitchDelay, maxPitchDelay, fracPartPitchDelay;
   Ipp32s   index, taming;
   Ipp32f pitchGain, codeGain;
   Ipp32s VADDecision;

   /* G.729 ANNEXE variables*/
   Ipp32s isSaturateAZ;
   Ipp32f EnergydB;

   Ipp32s avg_lag;
   Ipp32f tmp_lev;
   IppStatus sts;
   Ipp32s *anau;

   if(NULL==src || NULL ==dst)
      return APIG729_StsBadArgErr;
   if ((codecType != G729_CODEC)&&(codecType != G729A_CODEC)&&(codecType != G729D_CODEC)&&(codecType != G729E_CODEC))
      return APIG729_StsBadCodecType;
   if(encoderObj->objPrm.objSize <= 0)
      return APIG729_StsNotInitialized;
   if(ENC_KEY != encoderObj->objPrm.key)
      return APIG729_StsBadCodecType;

   ippsZero_32f(WeightedLPC1,BWD_LPC_ORDERP1);
   ippsZero_32f(WeightedLPC2,BWD_LPC_ORDERP1);

   anau = &EncodedParams[0];

   newSpeech = encoderObj->OldSpeechBuffer + SPEECH_BUFF_LEN - FRM_LEN;
   SpeechWnd     = newSpeech - LOOK_AHEAD_LEN;                    /* Present frame  */
   pWindow   = encoderObj->OldSpeechBuffer + SPEECH_BUFF_LEN - WINDOW_LEN;        /* For LPC window */
   WeightedSpeech    = encoderObj->OldWeightedSpeechBuffer + PITCH_LAG_MAX;
   Excitation    = encoderObj->OldExcitationBuffer + PITCH_LAG_MAX + INTERPOL_LEN;

   if(codecType!=G729A_CODEC){
      pZero   = encoderObj->UnitImpulse + BWD_LPC_ORDERP1;
      pError  = encoderObj->ErrFltMemory + BWD_LPC_ORDER;
      pSynth = encoderObj->SynthBuffer + BWD_SYNTH_MEM;
   }

   if (encoderObj->sFrameCounter == 32767) encoderObj->sFrameCounter = 256;
   else encoderObj->sFrameCounter++;

   ippsConvert_16s32f(src,newSpeech,FRM_LEN);
   ippsIIR_32f_I(newSpeech,FRM_LEN,encoderObj->iirstate);
#ifdef CLIPPING_DENORMAL_MODE
   ippsIIRGetDlyLine_32f(encoderObj->iirstate, TmpAlignVec);
   CLIP_DENORMAL_I(TmpAlignVec[0]);
   CLIP_DENORMAL_I(TmpAlignVec[1]);
   ippsIIRSetDlyLine_32f(encoderObj->iirstate, TmpAlignVec);
#endif
   ownAutoCorr_G729_32f(pWindow, LPC_ORDERP2, forwardAutoCorr,TmpAlignVec);             /* Autocorrelations */
   ippsCopy_32f(forwardAutoCorr, TmpAutoCorr, LPC_ORDERP1);

   /* Lag windowing    */
   ippsMul_32f_I(lwindow, &forwardAutoCorr[1], LPC_ORDERP2);
   /* Levinson Durbin  */
   tmp_lev = 0;
   sts = ippsLevinsonDurbin_G729_32f(forwardAutoCorr, LPC_ORDER, &forwardLPC[LPC_ORDERP1], forwardReflectCoeff, &tmp_lev);
   if(sts == ippStsOverflow) {
      ippsCopy_32f(encoderObj->OldForwardLPC,&forwardLPC[LPC_ORDERP1],LPC_ORDER+1);
      forwardReflectCoeff[0] = encoderObj->OldForwardRC[0];
      forwardReflectCoeff[1] = encoderObj->OldForwardRC[1];
   } else {
      ippsCopy_32f(&forwardLPC[LPC_ORDERP1],encoderObj->OldForwardLPC,LPC_ORDER+1);
      encoderObj->OldForwardRC[0] = forwardReflectCoeff[0];
      encoderObj->OldForwardRC[1] = forwardReflectCoeff[1];
   }


   /* Convert A(z) to lsp */
   if(codecType==G729A_CODEC){
      ippsLPCToLSP_G729A_32f(&forwardLPC[LPC_ORDERP1], encoderObj->OldLSP, CurrLSP);
   } else {
      ippsLPCToLSP_G729_32f(&forwardLPC[LPC_ORDERP1], encoderObj->OldLSP, CurrLSP);
   }

   if (encoderObj->objPrm.mode == G729Encode_VAD_Enabled) {
      ownACOS_G729_32f(CurrLSP, CurrLSF, LPC_ORDER);
      VoiceActivityDetect_G729_32f(forwardReflectCoeff[1], CurrLSF, forwardAutoCorr, pWindow, encoderObj->sFrameCounter,
                  encoderObj->prevVADDec, encoderObj->prevPrevVADDec, &VADDecision, &EnergydB,encoderObj->vadMem,TmpAlignVec);

      if(codecType!=G729A_CODEC){
         MusicDetection_G729E_32f( encoderObj, codecType, forwardAutoCorr[0],forwardReflectCoeff, &VADDecision, EnergydB,encoderObj->msdMem,TmpAlignVec);
      }

      UpdateCNG(TmpAutoCorr, VADDecision,encoderObj->cngMem);
   } else VADDecision = 1;

   if(VADDecision == 0) {
      if(codecType==G729A_CODEC){
         UpdateVad_A(encoderObj, Excitation, WeightedSpeech, SpeechWnd, anau);
      } else {
         /* Inactive frame */
         ippsCopy_32f(&encoderObj->SynthBuffer[FRM_LEN], &encoderObj->SynthBuffer[0], BWD_SYNTH_MEM);
         /* Find interpolated LPC parameters in all subframes unquantized.      *
         * The interpolated parameters are in array forwardLPC of size (LPC_ORDER+1)*4      */
         if( encoderObj->prevLPCMode == 0) {
            ippsInterpolateC_G729_32f(encoderObj->OldLSP, 0.5f, CurrLSP, 0.5f, tmpLSP, LPC_ORDER);

            ippsLSPToLPC_G729_32f(tmpLSP, forwardLPC);

            ownACOS_G729_32f(tmpLSP, InterpolatedLSF, LPC_ORDER);
            ownACOS_G729_32f(CurrLSP, CurrLSF, LPC_ORDER);
         } else {
            /* no interpolation */
            /* unquantized */
            ippsLSPToLPC_G729_32f(CurrLSP, forwardLPC); /* Subframe 1 */
            ownACOS_G729_32f(CurrLSP, CurrLSF, LPC_ORDER);  /* transformation from LSP to LSF (freq.domain) */
            ippsCopy_32f(CurrLSF, InterpolatedLSF, LPC_ORDER);      /* Subframe 1 */
         }

         if (encoderObj->sGlobalStatInd > 10000) {
            encoderObj->sGlobalStatInd -= 2621;
            if(encoderObj->sGlobalStatInd < 10000) encoderObj->sGlobalStatInd = 10000 ;
         }
         encoderObj->isBWDDominant = 0;
         encoderObj->fInterpolationCoeff = 1.1f;

         ippsCopy_32f(CurrLSP, encoderObj->OldLSP, LPC_ORDER);

         PWGammaFactor_G729(gamma1, gamma2, InterpolatedLSF, CurrLSF, forwardReflectCoeff,&encoderObj->isSmooth, encoderObj->LogAreaRatioCoeff);

         UpdateVad_I(encoderObj, Excitation, forwardLPC, WeightedSpeech, gamma1, gamma2, pSynth,
                     pError, SpeechWnd, anau, codecType);

         /* update previous filter for next frame */
         ippsCopy_32f(&forwardQntLPC[LPC_ORDERP1], encoderObj->PrevFlt, LPC_ORDERP1);
         for(i=LPC_ORDERP1; i <BWD_LPC_ORDERP1; i++) encoderObj->PrevFlt[i] = 0.f;
      }
      encoderObj->prevLPCMode = 0;

      encoderObj->fBetaPreFilter = PITCH_SHARPMIN;

      /* Update memories for next frames */
      ippsMove_32f(&encoderObj->OldSpeechBuffer[FRM_LEN], &encoderObj->OldSpeechBuffer[0], SPEECH_BUFF_LEN-FRM_LEN);
      ippsMove_32f(&encoderObj->OldWeightedSpeechBuffer[FRM_LEN], &encoderObj->OldWeightedSpeechBuffer[0], PITCH_LAG_MAX);
      ippsMove_32f(&encoderObj->OldExcitationBuffer[FRM_LEN], &encoderObj->OldExcitationBuffer[0], PITCH_LAG_MAX+INTERPOL_LEN);

      anau = EncodedParams+1;
      if(EncodedParams[0] == 0){ /* untransmitted*/
         *frametype=0;
      }else{
         *frametype=1; /* SID*/
         dst[0] = (Ipp8u)(((anau[0] & 0x1) << 7) | ((anau[1] & 0x1f) << 2) | ((anau[2] & 0xf)>>2)); /* 1+5+2  */
         dst[1] = (Ipp8u)(((anau[2] & 0x3) << 6) | ((anau[3] & 0x1f) << 1)); /* 2+5+LSB     */
      }
      CLEAR_SCRATCH_MEMORY(encoderObj);
      return APIG729_StsNoErr;
   }

   /* Active frame */

   *anau++ = CodecType2Num(codecType)+2; /* bit rate mode */
   if(encoderObj->objPrm.mode == G729Encode_VAD_Enabled) {
         encoderObj->sCNGSeed = INIT_SEED_VAL;
         encoderObj->prevPrevVADDec = encoderObj->prevVADDec;
         encoderObj->prevVADDec = VADDecision;
   }


   /* LSP quantization */

   ippsLSPQuant_G729E_32f( CurrLSP, (Ipp32f*)encoderObj->PrevFreq, CurrFreq, CurrQntLSP,  code_lsp);


   if( encoderObj->prevLPCMode == 0) {
      if(codecType!=G729A_CODEC){
         ippsInterpolateC_G729_32f(encoderObj->OldLSP, 0.5f, CurrLSP, 0.5f, tmpLSP, LPC_ORDER);

         ippsLSPToLPC_G729_32f(tmpLSP, forwardLPC);

         ownACOS_G729_32f(tmpLSP, InterpolatedLSF, LPC_ORDER);
         ownACOS_G729_32f(CurrLSP, CurrLSF, LPC_ORDER);
      }

      ippsInterpolateC_G729_32f(encoderObj->OldQuantLSP, 0.5f, CurrQntLSP, 0.5f, tmpLSP, LPC_ORDER);

      ippsLSPToLPC_G729_32f(tmpLSP, forwardQntLPC);
      ippsLSPToLPC_G729_32f(CurrQntLSP, &forwardQntLPC[LPC_ORDER+1]);
   } else {
      /* no interpolation */
      /* unquantized */
      ippsLSPToLPC_G729_32f(CurrLSP, forwardLPC); /* Subframe 1 */
      ownACOS_G729_32f(CurrLSP, CurrLSF, LPC_ORDER);  /* transformation from LSP to LSF (freq.domain) */
      ippsCopy_32f(CurrLSF, InterpolatedLSF, LPC_ORDER);      /* Subframe 1 */
      ippsLSPToLPC_G729_32f(CurrQntLSP, &forwardQntLPC[LPC_ORDERP1]); /* Subframe 2 */
      ippsCopy_32f(&forwardQntLPC[LPC_ORDERP1], forwardQntLPC, LPC_ORDERP1);      /* Subframe 1 */
   }

   /* Decision for the switch Forward / Backward mode */
   if(codecType == G729E_CODEC) {
      /* LPC recursive Window as in G728 */
      ippsWinHybrid_G729E_32f(encoderObj->SynthBuffer, backwardAutoCorr, encoderObj->pHWState);
      /* Lag windowing    */
      ippsMul_32f_I(lagBwd, &backwardAutoCorr[1], BWD_LPC_ORDER);
      if (backwardAutoCorr[0] < 1.0f) backwardAutoCorr[0] = 1.0f;
      sts = ippsLevinsonDurbin_G729_32f(backwardAutoCorr, BWD_LPC_ORDER, &backwardLPC[BWD_LPC_ORDERP1], backwardReflectCoeff, &tmp_lev);
      if(sts == ippStsOverflow) {
         ippsCopy_32f(encoderObj->OldBackwardLPC,&backwardLPC[BWD_LPC_ORDERP1],BWD_LPC_ORDER+1);
         backwardReflectCoeff[0] = encoderObj->OldBackwardRC[0];
         backwardReflectCoeff[1] = encoderObj->OldBackwardRC[1];
      } else {
         ippsCopy_32f(&backwardLPC[BWD_LPC_ORDERP1],encoderObj->OldBackwardLPC,BWD_LPC_ORDER+1);
         encoderObj->OldBackwardRC[0] = backwardReflectCoeff[0];
         encoderObj->OldBackwardRC[1] = backwardReflectCoeff[1];
      }

      /* Tests saturation of backwardLPC */
      isSaturateAZ = 0;
      for (i=BWD_LPC_ORDERP1; i<2*BWD_LPC_ORDERP1; i++) if (backwardLPC[i] >= 8.f) {isSaturateAZ = 1;break;}
      if (isSaturateAZ == 1) ippsCopy_32f(encoderObj->BackwardLPCMemory, &backwardLPC[BWD_LPC_ORDERP1], BWD_LPC_ORDERP1);
      else ippsCopy_32f(&backwardLPC[BWD_LPC_ORDERP1], encoderObj->BackwardLPCMemory, BWD_LPC_ORDERP1);

      /* Additional bandwidth expansion on backward filter */
      WeightLPCCoeff_G729(&backwardLPC[BWD_LPC_ORDERP1], BWD_GAMMA, BWD_LPC_ORDER, &backwardLPC[BWD_LPC_ORDERP1]);

      SetLPCMode_G729FPE(encoderObj,SpeechWnd, forwardQntLPC, backwardLPC, &LPCMode, CurrLSP,TmpAlignVec);
      *anau++ = LPCMode;
   } else {
      if (encoderObj->sGlobalStatInd > 10000) {
         encoderObj->sGlobalStatInd -= 2621;
         if( encoderObj->sGlobalStatInd < 10000) encoderObj->sGlobalStatInd = 10000 ;
      }
      LPCMode = 0;
      encoderObj->isBWDDominant = 0;
      encoderObj->fInterpolationCoeff = 1.1f;
   }
   /* Update synthesis signal for next frame.          */
   ippsCopy_32f(&encoderObj->SynthBuffer[FRM_LEN], &encoderObj->SynthBuffer[0], BWD_SYNTH_MEM);
   /* Update the LSPs for the next frame */
   ippsCopy_32f(CurrLSP, encoderObj->OldLSP, LPC_ORDER);
   if( LPCMode == 0) {
      ippsCopy_32f(CurrQntLSP, encoderObj->OldQuantLSP, LPC_ORDER);