short asiWspOld[PITCH_LAG_MAX / OPL_DECIM];
   short asiExcOld[PITCH_LAG_MAX + INTERPOL_LEN];
   short asiLevinsonMem[2*LP_ORDER];
   short asiIspOld[LP_ORDER];
   short asiIspQuantOld[LP_ORDER];
   short asiIsfQuantPast[LP_ORDER];
   short siWsp;
   short asiWspDecimate[3];
   short siSpeechWgt;
   short asiSynthesis[LP_ORDER];
   short siTiltCode;
   short siWspOldMax;
   short siWspOldShift;
   short siScaleFactorOld;
   short asiScaleFactorMax[2];
   short asiGainPitchClip[2];
   short asiGainQuant[4];
   short siMedianOld;
   short siOpenLoopGain;
   short siAdaptiveParam;
   short siWeightFlag;
   short asiPitchLagOld[5];
   IppsHighPassFilterState_AMRWB_16s *pSHPFiltStateWsp;
   short asiHypassFiltWspOld[FRAME_SIZE / OPL_DECIM + (PITCH_LAG_MAX / OPL_DECIM)];
   IppsVADState_AMRWB_16s *pSVadState;
   int   iDtx;
   SDtxEncoderState dtxEncState;
   short siFrameFirst;
   short asiIsfOld[LP_ORDER];
   int   iNoiseEnhancerThres;
   int   aiSynthMem[LP_ORDER];
   short siDeemph;
   short asiSynthHighFilt[LP_ORDER];
   HighPassFIRState_AMRWB_16s_ISfs *pSHPFIRState;
   HighPassFIRState_AMRWB_16s_ISfs *pSHPFIRState2;
   IppsHighPassFilterState_AMRWB_16s *pSHPFiltStateSgnlIn;
   IppsHighPassFilterState_AMRWB_16s *pSHPFiltStateSgnlOut;
   IppsHighPassFilterState_AMRWB_16s *pSHPFiltStateSgnl400;
   short siHFSeed;
   short siVadHist;
   short siAlphaGain;
   short siScaleExp;
   short siToneFlag;
};

struct _AMRWBDecoder_Obj
{
    SAMRWBCoderObj objPrm;
    short asiExcOld[PITCH_LAG_MAX + INTERPOL_LEN];
    short asiIspOld[LP_ORDER];
    short asiIsfOld[LP_ORDER];
    short asiIsf[3*LP_ORDER];
    short asiIsfQuantPast[LP_ORDER];
    short siTiltCode;
    short siScaleFactorOld;
    short asiScaleFactorMax[4];
    int   iNoiseEnhancerThres;
    int   asiSynthesis[LP_ORDER];
    short siDeemph;
    short asiOversampFilt[2*UP_SAMPL_FILT_DELAY];
    short asiSynthHighFilt[LP_ORDER_16K];
    HighPassFIRState_AMRWB_16s_ISfs *pSHighPassFIRState;
    HighPassFIRState_AMRWB_16s_ISfs *pSHighPassFIRState2;
    IppsHighPassFilterState_AMRWB_16s *pSHPFiltStateSgnlOut;
    IppsHighPassFilterState_AMRWB_16s *pSHPFiltStateSgnl400;
    short siSeed;
    short siHFSeed;
    short asiQuantEnerPast[4];
    short asiCodeGainPast[5];
    short asiQuantGainPast[5];
    short siCodeGainPrev;
    short asiPhaseDisp[8];
    short siBfiPrev;
    short siBFHState;
    short siFrameFirst;
    SDtxDecoderState dtxDecState;
    short siVadHist;
    IppsAdaptiveCodebookDecodeState_AMRWB_16s *pSAdaptCdbkDecState;
};

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

short ownDTXEncReset(SDtxEncoderState *st, short *pIsfInit);
short ownDTXEnc(SDtxEncoderState *st, short *pIsfvec, short *pExc2vec, unsigned short *pPrmsvec);
short ownDTXDecReset(SDtxDecoderState * st, short *pIsfInit);
short ownDTXDec(SDtxDecoderState *st, short *pExc2vec, short valDTXState, short *pIsfvec,
              const unsigned short *pPrmsvec);
short ownRXDTXHandler(SDtxDecoderState * st, short frameType);

/********************************************************
*      auxiliary inline functions declarations
*********************************************************/
__INLINE void ownMulC_16s_ISfs(short val, short *pSrcDst, int len, int scaleFactor)
{
    int i;
    for (i = 0; i < len; i++)
    {
        pSrcDst[i] = (pSrcDst[i] * val) >> scaleFactor;
    }
    return;
}

__INLINE void ownMulC_16s_Sfs(short *pSrc, short val, short *pDst, int len, int scaleFactor)
{
    int i;
    for (i = 0; i < len; i++)
    {
        pDst[i] = (pSrc[i] * val) >> scaleFactor;
    }
    return;
}

/* Random generator  */
__INLINE short Random(short *seed)
{
  *seed = *seed * 31821 + 13849;

  return(*seed);
}

__INLINE short Abs_16s(short x){
   if(x<0){
      if(IPP_MIN_16S == x) return IPP_MAX_16S;
      x = (short)-x;
   }
   return x;
}

__INLINE int Abs_32s(int x){
   if(x<0){
      if(IPP_MIN_32S == x) return IPP_MAX_32S;
      x = -x;
   }
   return x;
}

__INLINE int Add_32s(int x, int y) {
   Ipp64s z = (Ipp64s)x + y;
   if (z>IPP_MAX_32S) return IPP_MAX_32S;
   else if(z<IPP_MIN_32S)return IPP_MIN_32S;
   return (int)z;
}

extern CONST short NormTbl[256];
extern CONST short NormTbl2[256];

__INLINE short Exp_16s_Pos(unsigned short x)
{
   if((x>>8)==0)
      return NormTbl2[x];
   else {
      return NormTbl[(x>>8)];
   }
}

__INLINE short Exp_16s(short x){
   if (x == -1) return 15;
   if (x == 0) return 0;
   if (x < 0) x = ~x;
   return Exp_16s_Pos(x);
}

__INLINE short Exp_32s_Pos(int x){
   short i;
   if (x == 0) return 0;
   for(i = 0; x < (int)0x40000000; i++) x <<= 1;
   return i;
}

__INLINE short Exp_32s(int x){
   if (x == 0) return 0;
   if (x == -1) return 31;
   if (x < 0) x = ~x;
   return Exp_32s_Pos(x);
}

__INLINE short Norm_32s_I(int *x){
   short i;
   if (*x == 0) return 0;
   if (*x < 0){
      for(i = 0; *x >= (int)0xC0000000; i++) *x <<= 1;
   }else
      for(i = 0; *x < (int)0x40000000; i++) *x <<= 1;
   return i;
}

__INLINE short Cnvrt_32s16s(int x){
   if (IPP_MAX_16S < x) return IPP_MAX_16S;
   else if (IPP_MIN_16S > x) return IPP_MIN_16S;
   return (short)(x);
}

__INLINE short Cnvrt_NR_32s16s(int x) {
   short s = IPP_MAX_16S;
   if(x<(int)0x7fff8000) s = (x+0x8000)>>16;
   return s;
}

__INLINE int Negate_32s(int x) {
   if(IPP_MIN_32S == x)
      return IPP_MAX_32S;
   return (int)-x;
}

__INLINE int Mul2_32s(int x) {
    if(x > IPP_MAX_32S/2) return IPP_MAX_32S;
    else if( x < IPP_MIN_32S/2) return IPP_MIN_32S;
    return x <<= 1;
}

__INLINE int ShiftL_32s(int x, unsigned short n)
{
   int max = IPP_MAX_32S >> n;
   int min = IPP_MIN_32S >> n;
   if(x > max) return IPP_MAX_32S;
   else if(x < min) return IPP_MIN_32S;
   return (x<<n);
}

__INLINE short ShiftR_NR_16s(short x, unsigned short n){
   return (x + (1<<(n-1)))>>n;
}

__INLINE void L_Extract (int L_32, short *hi, short *lo)
{
    *hi = L_32 >> 16;
    *lo = (L_32>>1)&0x7fff;
    return;
}

__INLINE int Mpy_32_16 (short hi, short lo, short n)
{
    return (2 * (hi * n) +  2 * ((lo * n) >> 15));
}

__INLINE short Mul_16s_Sfs(short x, short y, int scaleFactor) {
   return (x * y) >> scaleFactor;
}

__INLINE int Mul_32s(int x,int y) {
   int z,z1,z2;
   short xh, xl, yh, yl;
   xh  = x >> 15;
   yh  = y >> 15;
   xl  = x & 0x7fff;
   yl  = y & 0x7fff;
   z1  = Mul_16s_Sfs(xh,yl,15);
   z2  = Mul_16s_Sfs(xl,yh,15);
   z   = xh * yh;
   z   += z1;
   z   += z2;
   return (z<<1);
}

__INLINE int Add_16s(short x, short y) {
   return Cnvrt_32s16s((int)x + (int)y);
}

#endif /*__OWNAMRWB_H__*/