owng729fp.h

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

void Post_G729E(G729FPDecoder_Obj *decoderObj, Ipp32s pitchDelay, Ipp32f *pSignal, Ipp32f *pLPC, Ipp32f *pDstFltSignal, Ipp32s *pVoicing,
                Ipp32s len, Ipp32s lenLPC, Ipp32s Vad);

typedef struct _G729CCoder_Obj {
   Ipp32s         objSize;
   Ipp32s         key;
   Ipp32u         mode;          /* coder mode's */
   G729Codec_Type codecType;
}G729CCoder_Obj;

#define SUMAUTOCORRS_NUM       3
#define SUMAUTOCORRS_SIZE      (SUMAUTOCORRS_NUM * LPC_ORDERP1)
#define CURRAUTOCORRS_NUM      2
#define AUTOCORRS_SIZE         (CURRAUTOCORRS_NUM * LPC_ORDERP1)
#define GAINS_NUM              2

extern CONST Ipp32f InitLSP[LPC_ORDER];
extern CONST Ipp32f InitFrequences[LPC_ORDER];
extern CONST Ipp32f lagBwd[BWD_LPC_ORDER];
extern CONST Ipp32f SIDGainTbl[32];

typedef struct _CNGmemory{
   Ipp32f AutoCorrs[AUTOCORRS_SIZE];
   Ipp32f SumAutoCorrs[SUMAUTOCORRS_SIZE];
   Ipp32f Energies[GAINS_NUM];
   Ipp32s lAutoCorrsCounter;
   Ipp32f fCurrGain;
   Ipp32s lFltChangeFlag;
   Ipp32f SIDQuantLSP[LPC_ORDER];
   Ipp32f ReflectCoeffs[LPC_ORDERP1];
   Ipp32s lNumSavedEnergies;
   Ipp32f fSIDGain;
   Ipp32f fPrevEnergy;
   Ipp32s lFrameCounter0;
}CNGmemory;

typedef struct _PSTmemory{
   Ipp32f STPNumCoeff[SHORTTERM_POSTFLT_LEN_E];  /* s.t. numerator coeff.        */
   Ipp32f STPMemory[BWD_LPC_ORDER];              /* s.t. postfilter memory       */
   Ipp32f ZeroMemory[BWD_LPC_ORDER];             /* null memory to compute h_st  */
   Ipp32f ResidualMemory[SIZE_RESISDUAL_MEMORY]; /* A(gamma2) residual           */
   Ipp32f gainPrec;
}PSTmemory;

typedef struct _MusDetectMemory{
   Ipp32s lMusicCounter;
   Ipp32f fMusicCounter;
   Ipp32s lZeroMusicCounter;
   Ipp32f fMeanPitchGain;
   Ipp32s lPFlagCounter;
   Ipp32f fMeanPFlagCounter;
   Ipp32s lConscPFlagCounter;
   Ipp32s lRCCounter;
   Ipp32f MeanRC[10];
   Ipp32f fMeanFullBandEnergy;
}MusDetectMemory;

typedef struct _PHDmemory{
   Ipp32s prevDispState;
   Ipp32f gainMem[6];
   Ipp32f prevCbGain;
   Ipp32s onset;
}PHDmemory;

struct _G729FPEncoder_Obj{
   G729CCoder_Obj      objPrm;
   ScratchMem_Obj      Mem;
   Ipp32f OldSpeechBuffer[SPEECH_BUFF_LEN];
   Ipp32f fBetaPreFilter;
   Ipp32f OldWeightedSpeechBuffer[FRM_LEN+PITCH_LAG_MAX];
   Ipp32f OldExcitationBuffer[FRM_LEN+PITCH_LAG_MAX+INTERPOL_LEN];
   Ipp32f WeightedFilterMemory[BWD_LPC_ORDER];
   Ipp32f FltMem[BWD_LPC_ORDER];
   Ipp32f OldLSP[LPC_ORDER];
   Ipp32f OldQuantLSP[LPC_ORDER];
   Ipp32f ExcitationError[4];
   IppsIIRState_32f *iirstate;
   Ipp32f PastQuantEnergy[4];
   Ipp32f PrevFreq[MOVING_AVER_ORDER][LPC_ORDER];    /* previous LSP vector       */
   /* Last forkward A(z) for case of unstable filter */
   Ipp32f OldForwardLPC[LPC_ORDERP1];
   Ipp32f OldForwardRC[2];
   Ipp16s sFrameCounter; /* frame counter for VAD*/
   /* DTX variables */
   Ipp32s prevVADDec;
   Ipp32s prevPrevVADDec;
   Ipp16s sCNGSeed;
   Ipp8s *vadMem;
   Ipp8s *cngMem;
   Ipp8s *msdMem;
   /* G729CA_CODEC*/
   Ipp32f ZeroMemory[LPC_ORDER];
   /* Not G.729A */
   Ipp32f SynFltMemory[BWD_LPC_ORDER];
   Ipp32f ErrFltMemory[BWD_LPC_ORDER+SUBFR_LEN];
   Ipp32f UnitImpulse[SUBFR_LEN+BWD_LPC_ORDERP1];
   /* for G.729E */
   /* for the backward analysis */
   Ipp32f PrevFlt[BWD_LPC_ORDERP1]; /* Previous selected filter */
   Ipp32f SynthBuffer[BWD_ANALISIS_WND_LEN];
   Ipp32s prevLPCMode;
   Ipp32f BackwardLPCMemory[BWD_LPC_ORDERP1];
   Ipp32s isBWDDominant;
   Ipp32f fInterpolationCoeff;
   Ipp16s sGlobalStatInd;  /* Mesure of global stationnarity */
   Ipp16s sBWDStatInd;       /* Num of consecutive backward frames */
   Ipp16s sValBWDStatInd;   /* Value associated with stat_bwd */
   /* Last backward A(z) for case of unstable filter */
   Ipp32f OldBackwardLPC[BWD_LPC_ORDERP1];
   Ipp32f OldBackwardRC[2];
   Ipp32s LagBuffer[5];
   Ipp32f PitchGainBuffer[5];
   Ipp32s  sBWDFrmCounter;
   Ipp32s sFWDFrmCounter;
   Ipp32s isSmooth;
   Ipp32f LogAreaRatioCoeff[2];
   Ipp32s sSearchTimes;
   IppsWinHybridState_G729E_32f *pHWState;
};

struct _G729FPDecoder_Obj{
   G729CCoder_Obj       objPrm;
   ScratchMem_Obj      Mem;
   Ipp32f OldExcitationBuffer[FRM_LEN+PITCH_LAG_MAX+INTERPOL_LEN];
   Ipp32f fBetaPreFilter;   /* pitch sharpening of previous frame */
   Ipp32s   prevPitchDelay; /* integer delay of previous frame    */
   Ipp32f fCodeGain;        /* Code gain                          */
   Ipp32f fPitchGain;       /* Pitch gain                         */
   Ipp32f OldLSP[LPC_ORDER];
   IppsIIRState_32f *iirstate;
   Ipp32f PastQuantEnergy[4];
   Ipp32f PrevFreq[MOVING_AVER_ORDER][LPC_ORDER];    /* previous LSP vector       */
   Ipp32s prevMA;                  /* previous MA prediction coef.*/
   Ipp32f prevLSF[LPC_ORDER];            /* previous LSF vector         */
   /* for G.729B */
   Ipp16s sFESeed;
   /* CNG variables */
   Ipp32s  prevFrameType;
   Ipp32s  prevSID[4];/*prev SID need for erased only*/
   Ipp16s sCNGSeed;
   Ipp32f SID;
   Ipp32f fCurrGain;
   Ipp32f SIDLSP[LPC_ORDER];
   Ipp32f fSIDGain;
   Ipp32f SynFltMemory[BWD_LPC_ORDER];        /* Synthesis filter's memory          */
   Ipp8s *phdMem;
   /* for G.729A */
   Ipp32f PstFltMemoryA[LPC_ORDER];
   Ipp32f fPastGain;
   Ipp32f ResidualBufferA[PITCH_LAG_MAX+SUBFR_LEN]; /* inverse filtered synthesis (with A(z/GAMMA2_POSTFLT))   */
   Ipp32f *ResidualMemory;
   Ipp32f PstSynMemoryA[LPC_ORDER];   /* memory of filter 1/A(z/GAMMA1_POSTFLT) */
   Ipp32f fPreemphMemoryA;
   /* Not G.729A */
   Ipp32f SynthBuffer[BWD_ANALISIS_WND_LEN];  /* Synthesis                   */
   Ipp32s   prevFracPitchDelay;    /* integer delay of previous frame    */
   /* for the backward analysis */
   Ipp32f BackwardUnqLPC[BWD_LPC_ORDERP1];
   Ipp32f BackwardLPCMemory[BWD_LPC_ORDERP1];
   Ipp32s   lPrevVoicing;
   Ipp32s   lPrevBFI;
   Ipp32s   prevLPCMode;
   Ipp32f fFEInterpolationCoeff;
   Ipp32f fInterpolationCoeff;
   Ipp32f PrevFlt[BWD_LPC_ORDERP1]; /* Previous selected filter */
   Ipp32s   lPrevPitchPT;
   Ipp32s   lStatPitchPT;
   Ipp32s   lStatPitch2PT;
   Ipp32s   lStatFracPT;
   /* Last backward A(z) for case of unstable filter */
   Ipp32f OldBackwardLPC[BWD_LPC_ORDERP1];
   Ipp32f OldBackwardRC[2];
   Ipp32f  fPitchGainMemory;
   Ipp32f  fCodeGainMemory;
   Ipp32f  fGainMuting;
   Ipp32s  lBFICounter;
   Ipp32s  sBWDStatInd;
   Ipp32s  lVoicing; /* voicing from previous frame */
   Ipp32f g1PST;
   Ipp32f g2PST;
   Ipp32f gHarmPST;
   Ipp32s  sBWDFrmCounter;
   Ipp32s sFWDFrmCounter;
   Ipp8s *pstMem;
   IppsWinHybridState_G729E_32f *pHWState;
};

#define   G729_CODECFUN(type,name,arg)                extern type name arg

__INLINE Ipp32s Parity( Ipp32s val){
  Ipp32s temp, nBits, bit;
  Ipp32s sum;

  temp = val >> 1;
  sum = 1;
  for (nBits = 0; nBits <= 5; nBits++) {
    temp = temp >> 1;
    bit = temp & 0x00000001;
    sum += bit;
  }
  sum = sum & 0x00000001;

  return sum;
}

__INLINE Ipp16s Rand_16s(Ipp16s *seed)
{
    *seed = (Ipp16s)(*seed * 31821 + 13849);
    return(*seed);
}

static __ALIGN32 CONST Ipp16s modtab[]={1, 2, 0, 1, 2, 0, 1, 2};

__INLINE void DecodeAdaptCodebookDelays(Ipp32s *prevPitchDelay, Ipp32s *prevFracPitchDelay,Ipp32s *delayLine,
                                         Ipp32s NSbfr, Ipp32s badPitch,Ipp32s pitchIndx,G729Codec_Type type){
   Ipp16s minPitchDelay, maxPitchDelay;

   if(badPitch == 0){

      if (NSbfr == 0)                  /* if 1st subframe */
      {
         if (pitchIndx < 197)
         {
            delayLine[0] = (pitchIndx+2)/3 + 19;
            delayLine[1] = pitchIndx - delayLine[0] * 3 + 58;
         }
         else
         {
            delayLine[0] = pitchIndx - 112;
            delayLine[1] = 0;
         }

      } else  {/* second subframe */
         /* find minPitchDelay and maxPitchDelay for 2nd subframe */
         minPitchDelay = (Ipp16s)(delayLine[0] - 5);
         CLIP_TO_LOWLEVEL(minPitchDelay,PITCH_LAG_MIN);

         maxPitchDelay = (Ipp16s)(minPitchDelay + 9);
         if (maxPitchDelay > PITCH_LAG_MAX)
         {
            maxPitchDelay = PITCH_LAG_MAX;
            minPitchDelay = (Ipp16s)(maxPitchDelay - 9);
         }
         if (type == G729D_MODE) {
            pitchIndx = pitchIndx & 15;
            if (pitchIndx <= 3) {
               delayLine[0] = minPitchDelay + pitchIndx;
               delayLine[1] = 0;
            }
            else if (pitchIndx < 12) {
               /* *T0_frac = index % 3; */
               delayLine[1] = modtab[pitchIndx - 4];
               delayLine[0] = (pitchIndx - delayLine[1])/3 + minPitchDelay + 2;

               if (delayLine[1] == 2) {
                  delayLine[1] = -1;
                  delayLine[0] += 1;
               }
            }
            else {
                delayLine[0] = minPitchDelay + pitchIndx - 6;
                delayLine[1] = 0;
            }

         }
         else {
            delayLine[0] = minPitchDelay + (pitchIndx + 2)/3 - 1;
            delayLine[1] = pitchIndx - 2 - 3 * ((pitchIndx + 2)/3 - 1);
         }
      }
      *prevPitchDelay = delayLine[0];
      *prevFracPitchDelay = delayLine[1];
   }else {                     /* Bad frame, or parity error */
      delayLine[0]  =  *prevPitchDelay;
      if (type == G729E_MODE) {
         delayLine[1] = *prevFracPitchDelay;
      }
      else {
         delayLine[1] = 0;
         *prevPitchDelay += 1;
         CLIP_TO_UPLEVEL(*prevPitchDelay,PITCH_LAG_MAX);
      }
   }
}

void CodewordImpConv_G729_32f(Ipp32s index, const Ipp32f *pSrc1,const Ipp32f *pSrc2,Ipp32f *pDst);

#define isVarZero(var) (fabs(var) < IPP_MINABS_32F)

#endif /* __OWNG729FP_H__ */