encg723.c

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

/*/////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2005-2007 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives
//     USC - Unified Speech Codec interface library
//
// By downloading and installing USC codec, you hereby agree that the
// accompanying Materials are being provided to you under the terms and
// conditions of the End User License Agreement for the Intel(R) Integrated
// Performance Primitives product previously accepted by you. Please refer
// to the file ippEULA.rtf or ippEULA.txt located in the root directory of your Intel(R) IPP
// product installation for more information.
//
// A speech coding standards promoted by ITU, ETSI, 3GPP and other
// organizations. Implementations of these standards, or the standard enabled
// platforms may require licenses from various entities, including
// Intel Corporation.
//
//
// Purpose: G.723.1 speech codec: encode API functions.
//
*/

#include "vadg723.h"
#include "owng723.h"

/* Declaration of local functions */
static void PastAverageFilter_G723(G723Encoder_Obj* encoderObj);
static void GetReflectionCoeff_G723(Ipp16s *pSrcLPC, Ipp16s *pDstReflectCoeff, Ipp16s *pDstReflectCoeffSFS);
static Ipp32s ItakuraDist_G723(Ipp16s *pSrcReflectCoeff, Ipp16s ReflectCoeffSFS, Ipp16s *pSrcAutoCorrs, Ipp16s energy);

static Ipp32s EncoderObjSize(void){
   Ipp32s fltSize;
   Ipp32s objSize = sizeof(G723Encoder_Obj);
   VoiceActivityDetectSize_G723(&fltSize);
   objSize += fltSize; /* VAD decision memory size*/
   return objSize;
}

G723_CODECFUN( APIG723_Status, apiG723Codec_ScratchMemoryAlloc,(Ipp32s *pCodecSize)) {
    if(NULL==pCodecSize)
        return APIG723_StsBadArgErr;
    *pCodecSize = G723_ENCODER_SCRATCH_MEMORY_SIZE;
    return APIG723_StsNoErr;
}

G723_CODECFUN( APIG723_Status, apiG723Encoder_Alloc, (Ipp32s *pCodecSize))
{
   *pCodecSize =  EncoderObjSize();
   return APIG723_StsNoErr;
}
G723_CODECFUN( APIG723_Status, apiG723Encoder_ControlMode,
         (G723Encoder_Obj* encoderObj, Ipp32u mode))
{
   encoderObj->objPrm.mode = mode;

   return APIG723_StsNoErr;
}

G723_CODECFUN( APIG723_Status, apiG723Encoder_Mode,
         (G723Encoder_Obj* encoderObj, Ipp32u mode))
{
   if (G723Encode_VAD_Enabled == mode)
      encoderObj->objPrm.mode |= G723Encode_VAD_Enabled;
   else{
      encoderObj->objPrm.mode |= G723Encode_VAD_Enabled;
      encoderObj->objPrm.mode ^= G723Encode_VAD_Enabled;
   }

   return APIG723_StsNoErr;
}

G723_CODECFUN( APIG723_Status, apiG723Encoder_Init,
              (G723Encoder_Obj* encoderObj, Ipp32u mode))
{
   Ipp32s i;
   Ipp8s* oldMemBuff;

   if(NULL==encoderObj)
      return APIG723_StsBadArgErr;

    oldMemBuff = encoderObj->Mem.base; /* if Reinit */

   ippsZero_16s((Ipp16s*)encoderObj,sizeof(G723Encoder_Obj)>>1) ;

   encoderObj->objPrm.objSize = EncoderObjSize();
   encoderObj->objPrm.mode = mode;
   encoderObj->objPrm.key = G723_ENC_KEY;
   encoderObj->objPrm.rat = 0; /* default 6.3 KBit/s*/

   encoderObj->vadMem  = (Ipp8s*)encoderObj + sizeof(G723Encoder_Obj);

   /* Initialize encoder data structure with zeros */
   ippsZero_16s(encoderObj->ZeroSignal, G723_SBFR_LEN);
   ippsZero_16s(encoderObj->UnitImpulseSignal, G723_SBFR_LEN); encoderObj->UnitImpulseSignal[0] = 0x2000 ; /* unit impulse */

   /* Initialize the previously decoded LSP vector to the DC vector */
   ippsCopy_16s(LPCDCTbl,encoderObj->PrevLPC,G723_LPC_ORDER);

   /* Initialize the taming procedure */
   for(i=0; i<5; i++) encoderObj->ExcitationError[i] = 4;
   encoderObj->sSearchTime = 120; /* reset max time */
   /* Initialize the VAD */
   //if(encoderObj->objPrm.mode & G723Encode_VAD_Enabled){
     VoiceActivityDetectInit_G723(encoderObj->vadMem);
     /* Initialize the CNG */
     encoderObj->CurrGain = 0;
     ippsZero_16s(encoderObj->AutoCorrs,AUOTOCORRS_BUFF_SIZE);

     for(i=0; i <= N_AUTOCORRS_BLOCKS; i++) encoderObj->AutoCorrsSFS[i] = 40;
     encoderObj->PrevOpenLoopLags[0] = G723_SBFR_LEN;
     encoderObj->PrevOpenLoopLags[1] = G723_SBFR_LEN;

     ippsZero_16s(encoderObj->LPCSID,G723_LPC_ORDER);
     ippsZero_16s(encoderObj->SIDLSP,G723_LPC_ORDER);
     ippsZero_16s(encoderObj->prevSidLpc,G723_LPC_ORDERP1);
     encoderObj->prevSidLpc[0] = 0x2000;
     ippsZero_16s(encoderObj->ReflectionCoeff,G723_LPC_ORDER+1);
     ippsZero_16s(encoderObj->GainAverEnergies,N_GAIN_AVER_FRMS);

     encoderObj->PastFrameType = G723_ActiveFrm;

     encoderObj->CNGSeed = 12345;
     encoderObj->CasheCounter = 0;
     encoderObj->ReflectionCoeffSFS = 0;
     encoderObj->AverEnerCounter = 0;
     encoderObj->PrevQGain = 0;
     encoderObj->sSidGain = 0;
   //}

   apiG723Encoder_InitBuff(encoderObj,oldMemBuff);

   return APIG723_StsNoErr;
}

G723_CODECFUN( APIG723_Status, apiG723Encoder_InitBuff,
         (G723Encoder_Obj* encoderObj, Ipp8s *buff))
{
   if(NULL==encoderObj) return APIG723_StsBadArgErr;
   if(NULL==buff) return APIG723_StsBadArgErr;

   if(buff)   encoderObj->Mem.base = buff; // otherwise reinit
   else if (encoderObj->Mem.base == NULL) return APIG723_StsNotInitialized;
   encoderObj->Mem.CurPtr = encoderObj->Mem.base;
   encoderObj->Mem.VecPtr = (Ipp32s *)(encoderObj->Mem.base+G723_ENCODER_SCRATCH_MEMORY_SIZE);

   return APIG723_StsNoErr;
}

void EncoderCNG_G723(G723Encoder_Obj* encoderObj, ParamStream_G723 *Params, Ipp16s *pExcitation, Ipp16s *pDstLPC)
{
   Ipp16s sQuantGain, sTmp;
   Ipp32s i;

   LOCAL_ARRAY(Ipp16s, curCoeff,G723_LPC_ORDER,encoderObj) ;

   for(i=N_GAIN_AVER_FRMS-1;i>=1;i--) encoderObj->GainAverEnergies[i]=encoderObj->GainAverEnergies[i-1];

   /* Calculate the LPC filter */
   ippsLevinsonDurbin_G723_16s( encoderObj->AutoCorrs, &sTmp, encoderObj->GainAverEnergies, curCoeff);

   /* if the first frame of silence => SID frame */
   if(encoderObj->PastFrameType == G723_ActiveFrm) {
      Params->FrameType = G723_SIDFrm;
      encoderObj->AverEnerCounter = 1;
      QuantSIDGain_G723_16s(encoderObj->GainAverEnergies, encoderObj->AutoCorrsSFS, encoderObj->AverEnerCounter,&i);
      sQuantGain=(Ipp16s)i;
   } else {
      encoderObj->AverEnerCounter++;
      if(encoderObj->AverEnerCounter > N_GAIN_AVER_FRMS) encoderObj->AverEnerCounter = N_GAIN_AVER_FRMS;
      QuantSIDGain_G723_16s(encoderObj->GainAverEnergies, encoderObj->AutoCorrsSFS, encoderObj->AverEnerCounter,&i);
      sQuantGain=(Ipp16s)i;

      /* Compute stationarity of current filter versus reference filter */
      if(ItakuraDist_G723(encoderObj->ReflectionCoeff, encoderObj->ReflectionCoeffSFS, encoderObj->AutoCorrs, *encoderObj->GainAverEnergies) == 0) {
         Params->FrameType = G723_SIDFrm; /* SID frame */
      } else {
         sTmp = (Ipp16s)Abs_16s(sQuantGain-encoderObj->PrevQGain);
         if(sTmp > 3) {
            Params->FrameType = G723_SIDFrm;/* SID frame */
         } else {
            Params->FrameType = G723_UntransmittedFrm;/* untransmitted */
         }
      }
   }

   if(Params->FrameType == G723_SIDFrm) { /* Compute SID filter */

      LOCAL_ARRAY(Ipp16s, qIndex,3,encoderObj) ;

      /* Check stationarity */

      PastAverageFilter_G723(encoderObj);


      if(!encoderObj->AdaptEnableFlag) /* adaptation enabled */
         for(i=0;i<G723_LPC_ORDER;i++)
            encoderObj->prevSidLpc[i+1] = (Ipp16s)(-encoderObj->LPCSID[i]);

      GetReflectionCoeff_G723(encoderObj->LPCSID , encoderObj->ReflectionCoeff, &encoderObj->ReflectionCoeffSFS);

      if(ItakuraDist_G723(encoderObj->ReflectionCoeff, encoderObj->ReflectionCoeffSFS, encoderObj->AutoCorrs, *encoderObj->GainAverEnergies) == 0){
         ippsCopy_16s(curCoeff,encoderObj->LPCSID,G723_LPC_ORDER);
         GetReflectionCoeff_G723(curCoeff, encoderObj->ReflectionCoeff, &encoderObj->ReflectionCoeffSFS);
      }

      /* Compute SID frame codes */
      ippsLPCToLSF_G723_16s(encoderObj->LPCSID,encoderObj->PrevLPC,encoderObj->SIDLSP);

      ippsLSFQuant_G723_16s32s(encoderObj->SIDLSP, encoderObj->PrevLPC, &Params->lLSPIdx);
      qIndex[2] =  (Ipp16s)(Params->lLSPIdx & 0xff);
      qIndex[1] =  (Ipp16s)((Params->lLSPIdx>>8) & 0xff);
      qIndex[0] =  (Ipp16s)((Params->lLSPIdx>>16) & 0xff);
      if(ippsLSFDecode_G723_16s(qIndex, encoderObj->PrevLPC,  0, encoderObj->SIDLSP) != ippStsNoErr)
         ippsCopy_16s(encoderObj->PrevLPC,encoderObj->SIDLSP,G723_LPC_ORDER);

      Params->sAmpIndex[0] = sQuantGain;
      encoderObj->PrevQGain = sQuantGain;
      DecodeSIDGain_G723_16s(encoderObj->PrevQGain,&encoderObj->sSidGain);

      LOCAL_ARRAY_FREE(Ipp16s, qIndex,3,encoderObj) ;
   }

   /* Compute new excitation */
   if(encoderObj->PastFrameType == G723_ActiveFrm) {
      encoderObj->CurrGain = encoderObj->sSidGain;
   } else {
      encoderObj->CurrGain = (Ipp16s)(( (encoderObj->CurrGain*0xE000)+
                              (encoderObj->sSidGain*0x2000) )>>16) ;
   }
   {

      LOCAL_ARRAY(Ipp8s, buff,ComfortNoiseExcitation_G723_16s_Buff_Size,encoderObj) ;

      ComfortNoiseExcitation_G723_16s(encoderObj->CurrGain, encoderObj->PrevExcitation, pExcitation,
                    &encoderObj->CNGSeed, Params->PitchLag,Params->AdCdbkLag,(Ipp16s*)Params->AdCdbkGain, Params->currRate, buff, &encoderObj->CasheCounter);