enum  enDTXStateType ownRX_DTX_Handler_GSMAMR(GSMAMRDecoder_Obj* decoderObj, RXFrameType frame_type);

int   ownDecSidSyncReset_GSMAMR(sDTXDecoderSt *st);
enum  enDTXStateType ownDecSidSync(sDTXDecoderSt *st, RXFrameType frame_type );

void  ownPrm2Bits_GSMAMR(const short* prm, unsigned char *Vout, GSMAMR_Rate_t rate );

void  ownBits2Prm_GSMAMR( const unsigned char *bitstream, short* prm , GSMAMR_Rate_t rate );

int   ownEncDetectSize_GSMAMR(int mode, int* pEncSize);

int   ownEncoderInit_GSMAMR(GSMAMREncoder_Obj* st);

int   ownDtxEncoderInit_GSMAMR(sDTXEncoderSt* st);

int   ownGainQuantInit_GSMAMR(sGainQuantSt *state);

int   ownVAD1Init_GSMAMR(IppGSMAMRVad1State *state);

int   ownVAD2Init_GSMAMR(IppGSMAMRVad2State *state);


/********************************************************
*               structs declarations
*********************************************************/

typedef struct _GSMAMRCoder_Obj{
   int                 objSize;
   int                 key;
   int                 mode;          /* encoder mode's */
   GSMAMRCodec_Type       codecType;
}GSMAMRCoder_Obj;

typedef struct {
   short a_SpeechVecOld[SPEECH_BUF_SIZE];
   short *pSpeechPtr, *pWindowPtr, *pWindowPtr_M122;
   short *pSpeechPtrNew;
   short a_WeightSpeechVecOld[FRAME_SIZE_GSMAMR + PITCH_MAX_LAG];
   short *pWeightSpeechVec;
   short a_LTPStateOld[5];
   short a_GainFlg[2];
   short a_ExcVecOld[FRAME_SIZE_GSMAMR + PITCH_MAX_LAG + FLT_INTER_SIZE];
   short *pExcVec;
   short a_ZeroVec[SUBFR_SIZE_GSMAMR + LP1_ORDER_SIZE];
   short *pZeroVec;
   short *pImpResVec;
   short a_ImpResVec[SUBFR_SIZE_GSMAMR];
   short a_SubState[LP_ORDER_SIZE + 1];
   short a_LSP_Old[LP_ORDER_SIZE];
   short a_LSPQnt_Old[LP_ORDER_SIZE];
   short a_PastQntPredErr[LP_ORDER_SIZE];
   short vTimePrevSubframe;
   sGainQuantSt stGainQntSt;
   short vTimeMedOld;
   short vFlagVADState;
   short vCount;
   short vFlagTone;
   short a_GainHistory[PG_NUM_FRAME];
   dVADState *pVAD1St;
   dVADState *pVAD2St;
   int vFlagDTX;
   sDTXEncoderSt stDTXEncState;
   short a_MemorySyn[LP_ORDER_SIZE], a_Memory_W0[LP_ORDER_SIZE];
   short a_MemoryErr[LP_ORDER_SIZE + SUBFR_SIZE_GSMAMR], *pErrorPtr;

   short vFlagSharp;
   short vFlagLTP;
   short vLagCountOld, vLagOld;
   short vBestHpCorr;

} sEncoderState_GSMAMR;


struct _GSMAMREncoder_Obj {
   GSMAMRCoder_Obj       objPrm;
/* preprocess state */
   char                  *preProc;      /* High pass pre processing filter memory */
   sEncoderState_GSMAMR  stEncState;
   GSMAMR_Rate_t         rate;          /* encode rate */
};


typedef struct{
   short a_ExcVecOld[SUBFR_SIZE_GSMAMR + PITCH_MAX_LAG + FLT_INTER_SIZE];
   short *pExcVec;
   short a_LSP_Old[LP_ORDER_SIZE];
   short a_MemorySyn[LP_ORDER_SIZE];
   short vFlagSharp;
   short vPrevPitchLag;
   short vPrevBadFr;
   short vPrevDegBadFr;
   short vStateMachine;
   short a_EnergyHistSubFr[9];
   short vLTPLag;
   short vBackgroundNoise;
   short vVoiceHangover;
   short a_LTPGainHistory[9];
   short a_EnergyHistVector[ENERGY_HIST_SIZE];
   short vCountHangover;
   short vCNGen;
   short a_GainHistory[CBGAIN_HIST_SIZE];
   short vHgAverageVar;
   short vHgAverageCount;
   short a_LSPAveraged[LP_ORDER_SIZE];
   short a_PastQntPredErr[LP_ORDER_SIZE];
   short a_PastLSFQnt[LP_ORDER_SIZE];
   short a_LSFBuffer[5];
   short vPastGainZero;
   short vPrevGainZero;
   short a_GainBuffer[5];
   short vPastGainCode;
   short vPrevGainCode;
   short a_PastQntEnergy_M122[4];
   short a_PastQntEnergy[4];
   sPhaseDispSt stPhDispState;
   sDTXDecoderSt dtxDecoderState;
} sDecoderState_GSMAMR;

struct _GSMAMRDecoder_Obj {
/* post process state */
   GSMAMRCoder_Obj       objPrm;
   char                  *postProc;     /* High pass post processing filter memory */
   sDecoderState_GSMAMR  stDecState;
   sPostFilterSt         stPFiltState;
   GSMAMR_Rate_t         rate;           /* decode rate */
};

int ownEncode_GSMAMR(sEncoderState_GSMAMR *st, GSMAMR_Rate_t rate, short ana[], int *pVad, short synth[]);

int ownDecoderInit_GSMAMR(sDecoderState_GSMAMR* state, GSMAMR_Rate_t rate);

int ownDtxDecoderInit_GSMAMR(sDTXDecoderSt* st);

int ownPhDispInit_GSMAMR(sPhaseDispSt* state);

int ownPostFilterInit_GSMAMR(sPostFilterSt *state);

#define   GSMAMR_CODECFUN(type,name,arg)                extern type name arg
/********************************************************
*      auxiliary inline functions declarations
*********************************************************/
__INLINE int ShiftL_32s(int n, unsigned short x)
{
   int z = n;
   for(;x>0;x--)
   {
      if (z > IPP_MAX_32S/2)
      {
         z = IPP_MAX_32S;
         break;
      }
      else
      {
        if (z < (int) 0xc0000000)
        {
           z = IPP_MIN_32S;
           break;
        }
      }
      z *= 2;
   }
   return z;
}
__INLINE short ShiftL_16s(short n, unsigned short x)
{
   short z = n;
   for(;x>0;x--)
   {
      if (z > (short) 0X3fff)
      {
         z = IPP_MAX_16S;
         break;
      }
      else
      {
        if (z < (short) 0xc000)
        {
           z = IPP_MIN_16S;
           break;
        }
      }
      z *= 2;
   }
   return z;
}
__INLINE int ownSqrt_32s( int n )
{
    int   i  ;

    short   x =  0 ;
    short   y =  0x4000 ;

    int   z ;

    for ( i = 0 ; i < 14 ; i ++ ) {
        z = (x + y) * (x + y ) ;
        if ( n >= z )
            x += y ;
        y >>= 1 ;
    }
    return x;
}
__INLINE short Abs_16s(short x){
   if(x<0){
      if(IPP_MIN_16S == x) return IPP_MAX_16S;
      x = (short)-x;
   }
   return 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 Cnvrt_64s32s(__INT64 z) {
   if(IPP_MAX_32S < z) return IPP_MAX_32S;
   else if(IPP_MIN_32S > z) return IPP_MIN_32S;
   return (int)z;
}
__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 int Add_32s(int x, int y) {
   return Cnvrt_64s32s((__INT64)x + y);
}
__INLINE int MulC_32s(short val, int x) {
   int z ;
   int xh, xl;
   xh  = x >> 16;
   xl  = x & 0xffff;
   z = 2*val*xh;
   z = Add_32s(z,(xl*val)>>15);

  return z;
}
__INLINE short Exp_16s(short x){
   short i;
   if (x == 0) return 0;
   if ((short)0xffff == x) return 15;
   if (x < 0) x = ~x;
   for(i = 0; x < (short)0x4000; i++) x <<= 1;
   return i;
}
__INLINE short   Rand2_16s( short *p ) /* GSMAMR */
{
    *p = *p * 521 + 259;
    return *p;
}

__INLINE short random_number(short np1, short *nRandom)
{
    short temp;

    temp = Rand2_16s(nRandom) & 0x7FFF;
    temp = (temp * np1)>>15;
    return temp;
}
__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 Norm_32s_Pos_I(int *x){
   short i;
   if (*x == 0) return 0;
   for(i = 0; *x < (int)0x40000000; i++) *x <<= 1;
   return i;
}
__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 int Mul16s_32s (short hi, short lo, short n)
{
    return (2 * (hi * n) +  2 * ((lo * n) >> 15));
}

__INLINE void L_Extract (int x, short *hi, short *lo)
{
    *hi = x >> 16;
    *lo = (x>>1)&0x7fff;
    return;
}
__INLINE int AddProduct_32s (int x, short hi1, short lo1, short hi2, short lo2)
{
    x += 2*(hi1*hi2) + 2*((hi1*lo2)>>15) + 2*((lo1*hi2)>>15);
    return x;
}

__INLINE int AddProduct16s_32s (int x, short hi, short lo, short n)
{
    x += 2*(hi*n) + 2*((lo*n)>>15);
    return x;
}
__INLINE int Mul2_32s(int x) {
    if(x > IPP_MAX_32S/2) return IPP_MAX_32S;
    else if( x < (int) 0xc0000000L) return IPP_MIN_32S;
    return (x <<= 1);
}
__INLINE int Mul4_32s(int x) {
    if(x > (int) 0x1fffffffL) return IPP_MAX_32S;
    else if( x < (int) 0xe0000000L) return IPP_MIN_32S;
    return (x <<= 2);
}
__INLINE int Mul8_32s(int x) {
    if(x > (int) 0x0fffffffL) return IPP_MAX_32S;
    else if( x < (int) 0xf0000000L) return IPP_MIN_32S;
    return (x <<= 3);
}

__INLINE int Mul16_32s(int x) {
    if(x > (int) 0x07ffffffL) return IPP_MAX_32S;
    else if( x < (int) 0xf8000000L) return IPP_MIN_32S;
    return (x <<= 4);
}

#endif /*__OWNGSMAMR_H__*/