encg723.c

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

      LOCAL_ARRAY_FREE(Ipp8s, buff,ComfortNoiseExcitation_G723_16s_Buff_Size,encoderObj) ;
   }

   LSPInterpolation(encoderObj->SIDLSP, encoderObj->PrevLPC, pDstLPC);/* Interpolate LSPs */
   ippsCopy_16s(encoderObj->SIDLSP,encoderObj->PrevLPC,G723_LPC_ORDER); /* update prev SID LPC */

   encoderObj->PastFrameType = Params->FrameType;
   LOCAL_ARRAY_FREE(Ipp16s, curCoeff,G723_LPC_ORDER,encoderObj) ;
   return;
}

void UpdateAutoCorrs_G723(G723Encoder_Obj* encoderObj, const Ipp16s *pSrcAutoCorrs, const Ipp16s *pSrcAutoCorrsSFS)
{

   Ipp32s i, lNsbfr;
   Ipp16s sMinSFS, sTmp;
   Ipp16s m1, m2;

   LOCAL_ARRAY(Ipp32s, lSumAutoCorrs,G723_LPC_ORDER+1,encoderObj) ;

   /* Update Acf and ShAcf */
   for(i=0; i<AUOTOCORRS_BUFF_SIZE-G723_LPC_ORDER-1; i++) encoderObj->AutoCorrs[AUOTOCORRS_BUFF_SIZE-1-i] = encoderObj->AutoCorrs[AUOTOCORRS_BUFF_SIZE-G723_LPC_ORDER-2-i];

   for(i=N_AUTOCORRS_BLOCKS; i>=1; i--) encoderObj->AutoCorrsSFS[i] = encoderObj->AutoCorrsSFS[i-1];

   /* Search the min of pSrcAutoCorrsSFS */
   m1 = (Ipp16s)IPP_MIN(pSrcAutoCorrsSFS[0],pSrcAutoCorrsSFS[1]);
   m2 = (Ipp16s)IPP_MIN(pSrcAutoCorrsSFS[2],pSrcAutoCorrsSFS[3]);
   sMinSFS = (Ipp16s)((IPP_MIN(m1,m2))+14);

   /* Calculate the acfs sum */
   ippsZero_16s((Ipp16s*)lSumAutoCorrs,2*G723_LPC_ORDERP1);

   for(lNsbfr=0; lNsbfr<4; lNsbfr++) {
      sTmp = (Ipp16s)(sMinSFS - pSrcAutoCorrsSFS[lNsbfr]);
      if(sTmp < 0) {
         sTmp = (Ipp16s)(-sTmp);
         for(i=0; i <= G723_LPC_ORDER; i++) {
            lSumAutoCorrs[i] += (pSrcAutoCorrs[lNsbfr*G723_LPC_ORDERP1+i]>>sTmp);
         }
      } else {
         for(i=0; i <= G723_LPC_ORDER; i++) {
            lSumAutoCorrs[i] += (pSrcAutoCorrs[lNsbfr*G723_LPC_ORDERP1+i]<<sTmp);
         }
      }
   }
   /* Normalize */
   sTmp = Exp_32s_Pos(lSumAutoCorrs[0]);
   sTmp = (Ipp16s)(16 - sTmp); if(sTmp < 0) sTmp = 0;

   for(i=0;i<=G723_LPC_ORDER;i++) encoderObj->AutoCorrs[i]=(Ipp16s)(lSumAutoCorrs[i]>>sTmp);
   encoderObj->AutoCorrsSFS[0] = (Ipp16s)(sMinSFS - sTmp);

   LOCAL_ARRAY_FREE(Ipp32s, lSumAutoCorrs,G723_LPC_ORDER+1,encoderObj) ;

   return;
}

void PastAverageFilter_G723(G723Encoder_Obj* encoderObj)
{
   Ipp32s i, j;
   Ipp16s sMinSFS, sTmp;

   LOCAL_ARRAY(Ipp32s, lSumAutoCorrs,G723_LPC_ORDER+1,encoderObj) ;
   LOCAL_ARRAY(Ipp16s, pCorr,G723_LPC_ORDER+1,encoderObj) ;

   /* Search ShAcf min */
   sMinSFS = (Ipp16s)IPP_MIN(encoderObj->AutoCorrsSFS[1],encoderObj->AutoCorrsSFS[2]);
   sMinSFS = (Ipp16s)((IPP_MIN(sMinSFS,encoderObj->AutoCorrsSFS[3]))+14);

   ippsZero_16s((Ipp16s*)lSumAutoCorrs,2*G723_LPC_ORDERP1);

   for(i=1; i <= N_AUTOCORRS_BLOCKS; i ++) {
      sTmp = (Ipp16s)(sMinSFS - encoderObj->AutoCorrsSFS[i]);
      if(sTmp < 0) {
         sTmp=(Ipp16s)(-sTmp);
         for(j=0; j <= G723_LPC_ORDER; j++) {
            lSumAutoCorrs[j] += (encoderObj->AutoCorrs[i*G723_LPC_ORDERP1+j]>>sTmp);
         }
      } else {
         for(j=0; j <= G723_LPC_ORDER; j++) {
            lSumAutoCorrs[j] += (encoderObj->AutoCorrs[i*G723_LPC_ORDERP1+j]<<sTmp);
         }
      }
   }

   /* Normalize */
   sTmp = Exp_32s_Pos(lSumAutoCorrs[0]);
   sTmp = (Ipp16s)(16 - sTmp);
   if(sTmp < 0) sTmp = 0;

   for(i=0; i<G723_LPC_ORDER+1; i++) {
      pCorr[i] = (Ipp16s)(lSumAutoCorrs[i]>>sTmp);
   }

   ippsLevinsonDurbin_G723_16s(pCorr, &sTmp, &sTmp, encoderObj->LPCSID);

   LOCAL_ARRAY_FREE(Ipp16s, pCorr,G723_LPC_ORDER+1,encoderObj) ;
   LOCAL_ARRAY_FREE(Ipp32s, lSumAutoCorrs,G723_LPC_ORDER+1,encoderObj) ;

   return;
}

void GetReflectionCoeff_G723(Ipp16s *pSrcLPC, Ipp16s *pDstReflectCoeff, Ipp16s *pDstReflectCoeffSFS)
{
   Ipp32s i, j;
   Ipp16s SFS;
   Ipp32s lCorr;

   ippsDotProd_16s32s_Sfs(pSrcLPC,pSrcLPC,G723_LPC_ORDER,&lCorr,-1);
   lCorr = lCorr >> 1;
   lCorr = lCorr + 0x04000000;
   SFS = (Ipp16s)(Exp_32s_Pos(lCorr) - 2);
   *pDstReflectCoeffSFS = SFS;
   if(SFS > 0) {
      lCorr = ShiftL_32s(lCorr, SFS);
      pDstReflectCoeff[0] = Cnvrt_NR_32s16s(lCorr);

      for(i=1; i<=G723_LPC_ORDER; i++) {
         lCorr = -(pSrcLPC[i-1]<<13);
         for(j=0; j<G723_LPC_ORDER-i; j++) {
            lCorr = Add_32s(lCorr, pSrcLPC[j]*pSrcLPC[j+i]);
         }
         lCorr = (Ipp32s)(ShiftL_32s(lCorr, (Ipp16u)(SFS+1)));
         pDstReflectCoeff[i] = Cnvrt_NR_32s16s(lCorr);
      }
   } else {
      SFS = (Ipp16s)(-SFS);
      lCorr = lCorr>>SFS;
      pDstReflectCoeff[0] = Cnvrt_NR_32s16s(lCorr);

      for(i=1; i<=G723_LPC_ORDER; i++) {
         lCorr = -(pSrcLPC[i-1]<<13);
         for(j=0; j<G723_LPC_ORDER-i; j++) {
            lCorr = Add_32s(lCorr, pSrcLPC[j]*pSrcLPC[j+i]);
         }
         lCorr = Mul2_32s(lCorr)>>(SFS);
         pDstReflectCoeff[i] = Cnvrt_NR_32s16s(lCorr);
      }
   }
   return;
}


Ipp32s ItakuraDist_G723(Ipp16s *pSrcReflectCoeff, Ipp16s ReflectCoeffSFS, Ipp16s *pSrcAutoCorrs, Ipp16s energy)
{
    Ipp32s i, lSum, lThresh;

    lSum = 0;
    for(i=0; i <= G723_LPC_ORDER; i++) {
        lSum += pSrcReflectCoeff[i] * (pSrcAutoCorrs[i]>>2);
    }

    lThresh = Cnvrt_32s16s(((energy * 7000)+0x4000)>>15) + energy;
    lThresh <<= (ReflectCoeffSFS + 8);

    /* The condition (lSum < lThresh) has been corrected to the new condition (lSum <= lThresh). */
    /* The g723.1 speech codec has worked with digital silence incorrectly by use the old condition. */
    return ((lSum <= lThresh));
}

G723_CODECFUN(  APIG723_Status, apiG723Encode,
         (G723Encoder_Obj* encoderObj,const Ipp16s* src, Ipp16s rat, Ipp8s* pDstBitStream ))
{
   Ipp32s  i, lNSbfr;

   LOCAL_ALIGN_ARRAY(16, Ipp16s, HPFltSignal,G723_FRM_LEN, encoderObj);
   LOCAL_ALIGN_ARRAY(16, Ipp16s, AlignTmpVec,G723_MAX_PITCH+G723_FRM_LEN, encoderObj);
   LOCAL_ALIGN_ARRAY(16, Ipp16s, CurrLPC,4*G723_LPC_ORDER, encoderObj) ;
   LOCAL_ALIGN_ARRAY(16, Ipp16s, CurrQLPC,4*(G723_LPC_ORDER+1), encoderObj) ;
   LOCAL_ALIGN_ARRAY(16, Ipp16s, WeightedLPC,8*G723_LPC_ORDER, encoderObj) ;
   LOCAL_ALIGN_ARRAY(16, Ipp16s, CurrLSF,G723_LPC_ORDER, encoderObj) ;
   LOCAL_ARRAY(GainInfo_G723, GainInfo,4, encoderObj) ;

   ParamStream_G723 CurrentParams;

   Ipp16s *pData;
   Ipp16s isNotSineWave;

   CurrentParams.FrameType = G723_ActiveFrm;

   if(NULL==encoderObj || NULL==src || NULL ==pDstBitStream)
      return APIG723_StsBadArgErr;
   if(encoderObj->objPrm.objSize <= 0)
      return APIG723_StsNotInitialized;
   if(G723_ENC_KEY != encoderObj->objPrm.key)
      return APIG723_StsBadCodecType;

   if(rat < 0 || rat > 1) {
      rat = (Ipp16s)encoderObj->objPrm.rat;
   } else {
      encoderObj->objPrm.rat = rat;
   }

   CurrentParams.currRate = (G723_Rate)rat;
   if ( CurrentParams.currRate == G723_Rate53)     encoderObj->sSearchTime = 120; /* reset max time */

   CurrentParams.isBadFrame = (Ipp16s) 0 ;

   if ( encoderObj->objPrm.mode&G723Encode_HF_Enabled ) {
      /*    High-pass filtering.   Section 2.3 */
      ippsHighPassFilter_G723_16s(src,HPFltSignal,encoderObj->HPFltMem);
   } else {
      ippsRShiftC_16s(src,1,HPFltSignal,G723_FRM_LEN);
   }

   /* Compute the Unquantized Lpc */
   {

       Ipp16s  sTmp;

       LOCAL_ALIGN_ARRAY(16, Ipp16s, AutoCorrs,(G723_LPC_ORDER+1)*4,encoderObj) ;
       LOCAL_ARRAY(Ipp16s, AutoCorrsSFS,4,encoderObj) ;

       ippsCopy_16s(encoderObj->SignalDelayLine,AlignTmpVec,G723_HALFFRM_LEN);
       ippsCopy_16s(HPFltSignal,&AlignTmpVec[G723_HALFFRM_LEN],G723_FRM_LEN);

       ippsAutoCorr_G723_16s(AlignTmpVec,&AutoCorrsSFS[0],AutoCorrs);
       ippsAutoCorr_G723_16s(&AlignTmpVec[G723_SBFR_LEN],&AutoCorrsSFS[1],&AutoCorrs[G723_LPC_ORDERP1]);
       ippsAutoCorr_G723_16s(&AlignTmpVec[2*G723_SBFR_LEN],&AutoCorrsSFS[2],&AutoCorrs[2*G723_LPC_ORDERP1]);
       ippsAutoCorr_G723_16s(&AlignTmpVec[3*G723_SBFR_LEN],&AutoCorrsSFS[3],&AutoCorrs[3*G723_LPC_ORDERP1]);

       /* LPC calculation for all subframes */

       ippsLevinsonDurbin_G723_16s( AutoCorrs, &encoderObj->SineWaveDetector, &sTmp , CurrLPC);
       ippsLevinsonDurbin_G723_16s( &AutoCorrs[G723_LPC_ORDERP1], &encoderObj->SineWaveDetector, &sTmp , &CurrLPC[G723_LPC_ORDER]);
       ippsLevinsonDurbin_G723_16s( &AutoCorrs[2*G723_LPC_ORDERP1], &encoderObj->SineWaveDetector, &sTmp , &CurrLPC[2*G723_LPC_ORDER]);
       ippsLevinsonDurbin_G723_16s( &AutoCorrs[3*G723_LPC_ORDERP1], &encoderObj->SineWaveDetector, &sTmp , &CurrLPC[3*G723_LPC_ORDER]);

       /* Update sine detector */
       UpdateSineDetector(&encoderObj->SineWaveDetector, &isNotSineWave);
       /* Update CNG Acf memories */
       UpdateAutoCorrs_G723(encoderObj, AutoCorrs, AutoCorrsSFS);

       LOCAL_ARRAY_FREE(Ipp16s, AutoCorrsSFS,4,encoderObj) ;
       LOCAL_ALIGN_ARRAY_FREE(16, Ipp16s, AutoCorrs,(G723_LPC_ORDER+1)*4,encoderObj) ;

   }
   /* Convert to Lsp */
   ippsLPCToLSF_G723_16s(&CurrLPC[G723_LPC_ORDER*3], encoderObj->PrevLPC, CurrLSF);