/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
/****************************************************************************************
Portions of this file are derived from the following 3GPP standard:

    3GPP TS 26.073
    ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
    Available from http://www.3gpp.org

(C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
Permission to distribute, modify and use this file under the standard license
terms listed above has been obtained from the copyright holder.
****************************************************************************************/
/*
------------------------------------------------------------------------------

 Pathname: ./audio/gsm-amr/c/src/dec_amr.c
 Funtions: Decoder_amr_init
           Decoder_amr_reset
           Decoder_amr

------------------------------------------------------------------------------
 MODULE DESCRIPTION

 This file contains the function used to decode one speech frame using a given
 codec mode. The functions used to initialize, reset, and exit are also
 included in this file.

------------------------------------------------------------------------------
*/

/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/
#include "dec_amr.h"
#include "typedef.h"
#include "cnst.h"
#include "copy.h"
#include "set_zero.h"
#include "syn_filt.h"
#include "d_plsf.h"
#include "agc.h"
#include "int_lpc.h"
#include "dec_gain.h"
#include "dec_lag3.h"
#include "dec_lag6.h"
#include "d2_9pf.h"
#include "d2_11pf.h"
#include "d3_14pf.h"
#include "d4_17pf.h"
#include "d8_31pf.h"
#include "d1035pf.h"
#include "pred_lt.h"
#include "d_gain_p.h"
#include "d_gain_c.h"
#include "dec_gain.h"
#include "ec_gains.h"
#include "ph_disp.h"
#include "c_g_aver.h"
#include "int_lsf.h"
#include "lsp_lsf.h"
#include "lsp_avg.h"
#include "bgnscd.h"
#include "ex_ctrl.h"
#include "sqrt_l.h"
#include "frame.h"
#include "bitno_tab.h"
#include "b_cn_cod.h"
#include "basic_op.h"
#include "oscl_mem.h"

/*----------------------------------------------------------------------------
; MACROS
; Define module specific macros here
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; DEFINES
; Include all pre-processor statements here. Include conditional
; compile variables also.
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; LOCAL FUNCTION DEFINITIONS
; Function Prototype declaration
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; LOCAL VARIABLE DEFINITIONS
; Variable declaration - defined here and used outside this module
----------------------------------------------------------------------------*/


/*
------------------------------------------------------------------------------
 FUNCTION NAME: Decoder_amr_init
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    state = pointer to a pointer to structures of type Decoder_amrState

 Outputs:
    structure pointed to by the pointer which is pointed to by state is
      initialized to each field's initial values

    state pointer points to the address of the memory allocated by
      Decoder_amr_init function

 Returns:
    return_value = 0, if the initialization was successful; -1, otherwise (int)

 Global Variables Used:
    None

 Local Variables Needed:
    None

------------------------------------------------------------------------------
 FUNCTION DESCRIPTION

 This function allocates and initializes state memory used by the Decoder_amr
 function. It stores the pointer to the filter status structure in state. This
 pointer has to be passed to Decoder_amr in each call. The function returns
 0, if initialization was successful and -1, otherwise.

------------------------------------------------------------------------------
 REQUIREMENTS

 None

------------------------------------------------------------------------------
 REFERENCES

 dec_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

------------------------------------------------------------------------------
 PSEUDO-CODE

int Decoder_amr_init (Decoder_amrState **state)
{
  Decoder_amrState* s;
  Word16 i;

  if (state == (Decoder_amrState **) NULL){
      fprintf(stderr, "Decoder_amr_init: invalid parameter\n");
      return -1;
  }
  *state = NULL;

  // allocate memory
  if ((s= (Decoder_amrState *) malloc(sizeof(Decoder_amrState))) == NULL){
      fprintf(stderr, "Decoder_amr_init: can not malloc state structure\n");
      return -1;
  }

  s->T0_lagBuff = 40;
  s->inBackgroundNoise = 0;
  s->voicedHangover = 0;
  for (i = 0; i < 9; i++)
     s->ltpGainHistory[i] = 0;

  s->lsfState = NULL;
  s->ec_gain_p_st = NULL;
  s->ec_gain_c_st = NULL;
  s->pred_state = NULL;
  s->ph_disp_st = NULL;
  s->dtxDecoderState = NULL;

  if (D_plsf_init(&s->lsfState) ||
      ec_gain_pitch_init(&s->ec_gain_p_st) ||
      ec_gain_code_init(&s->ec_gain_c_st) ||
      gc_pred_init(&s->pred_state) ||
      Cb_gain_average_init(&s->Cb_gain_averState) ||
      lsp_avg_init(&s->lsp_avg_st) ||
      Bgn_scd_init(&s->background_state) ||
      ph_disp_init(&s->ph_disp_st) ||
      dtx_dec_init(&s->dtxDecoderState)) {
      Decoder_amr_exit(&s);
      return -1;
  }

  Decoder_amr_reset(s, (enum Mode)0);
  *state = s;

  return 0;
}

------------------------------------------------------------------------------
 RESOURCES USED [optional]

 When the code is written for a specific target processor the
 the resources used should be documented below.

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

 CLOCK CYCLES: (cycle count equation for this function) + (variable
                used to represent cycle count for each subroutine
                called)
     where: (cycle count variable) = cycle count for [subroutine
                                     name]

------------------------------------------------------------------------------
 CAUTION [optional]
 [State any special notes, constraints or cautions for users of this function]

------------------------------------------------------------------------------
*/

Word16 Decoder_amr_init(Decoder_amrState *s)
{
    Word16 i;

    if (s == (Decoder_amrState *) NULL)
    {
        /* fprint(stderr, "Decoder_amr_init: invalid parameter\n");  */
        return(-1);
    }

    s->T0_lagBuff = 40;
    s->inBackgroundNoise = 0;
    s->voicedHangover = 0;

    /* Initialize overflow Flag */

    s->overflow = 0;

    for (i = 0; i < LTP_GAIN_HISTORY_LEN; i++)
    {
        s->ltpGainHistory[i] = 0;
    }

    D_plsf_reset(&s->lsfState);
    ec_gain_pitch_reset(&s->ec_gain_p_st);
    ec_gain_code_reset(&s->ec_gain_c_st);
    Cb_gain_average_reset(&s->Cb_gain_averState);
    lsp_avg_reset(&s->lsp_avg_st);
    Bgn_scd_reset(&s->background_state);
    ph_disp_reset(&s->ph_disp_st);
    dtx_dec_reset(&s->dtxDecoderState);
    gc_pred_reset(&s->pred_state);

    Decoder_amr_reset(s, MR475);

    return(0);
}

/****************************************************************************/

/*
------------------------------------------------------------------------------
 FUNCTION NAME: Decoder_amr_reset
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    state = pointer to a structure of type Decoder_amrState
    mode = codec mode (enum Mode)

 Outputs:
    structure pointed to by state is initialized to its reset value

 Returns:
    return_value = 0, if reset was successful; -1, otherwise (int)

 Global Variables Used:
    None

 Local Variables Needed:
    None

------------------------------------------------------------------------------
 FUNCTION DESCRIPTION

 This function resets the state memory used by the Decoder_amr function. It
 returns a 0, if reset was successful and -1, otherwise.

------------------------------------------------------------------------------
 REQUIREMENTS

 None

------------------------------------------------------------------------------
 REFERENCES

 dec_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

------------------------------------------------------------------------------
 PSEUDO-CODE

int Decoder_amr_reset (Decoder_amrState *state, enum Mode mode)
{
  Word16 i;

  if (state == (Decoder_amrState *) NULL){
      fprintf(stderr, "Decoder_amr_reset: invalid parameter\n");
      return -1;
  }

  // Initialize static pointer
  state->exc = state->old_exc + PIT_MAX + L_INTERPOL;

  // Static vectors to zero
  Set_zero (state->old_exc, PIT_MAX + L_INTERPOL);

  if (mode != MRDTX)
     Set_zero (state->mem_syn, M);

  // initialize pitch sharpening
  state->sharp = SHARPMIN;
  state->old_T0 = 40;

  // Initialize state->lsp_old []

  if (mode != MRDTX) {
      Copy(lsp_init_data, &state->lsp_old[0], M);
  }

  // Initialize memories of bad frame handling
  state->prev_bf = 0;
  state->prev_pdf = 0;
  state->state = 0;

  state->T0_lagBuff = 40;
  state->inBackgroundNoise = 0;
  state->voicedHangover = 0;
  if (mode != MRDTX) {
      for (i=0;i<9;i++)
          state->excEnergyHist[i] = 0;
  }

  for (i = 0; i < 9; i++)
     state->ltpGainHistory[i] = 0;

  Cb_gain_average_reset(state->Cb_gain_averState);
  if (mode != MRDTX)
     lsp_avg_reset(state->lsp_avg_st);
  D_plsf_reset(state->lsfState);
  ec_gain_pitch_reset(state->ec_gain_p_st);
  ec_gain_code_reset(state->ec_gain_c_st);

  if (mode != MRDTX)
     gc_pred_reset(state->pred_state);

  Bgn_scd_reset(state->background_state);
  state->nodataSeed = 21845;
  ph_disp_reset(state->ph_disp_st);
  if (mode != MRDTX)
     dtx_dec_reset(state->dtxDecoderState);

  return 0;
}

------------------------------------------------------------------------------
 RESOURCES USED [optional]

 When the code is written for a specific target processor the
 the resources used should be documented below.

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

 CLOCK CYCLES: (cycle count equation for this function) + (variable
                used to represent cycle count for each subroutine
                called)
     where: (cycle count variable) = cycle count for [subroutine
                                     name]

------------------------------------------------------------------------------
 CAUTION [optional]
 [State any special notes, constraints or cautions for users of this function]

------------------------------------------------------------------------------
*/

Word16 Decoder_amr_reset(Decoder_amrState *state, enum Mode mode)
{
    Word16 i;

    if (state == (Decoder_amrState *) NULL)
    {
        /* fprint(stderr, "Decoder_amr_reset: invalid parameter\n");  */
        return(-1);
    }

    /* Initialize static pointer */
    state->exc = state->old_exc + PIT_MAX + L_INTERPOL;

    /* Static vectors to zero */
    oscl_memset(state->old_exc, 0, sizeof(Word16)*(PIT_MAX + L_INTERPOL));

    if (mode != MRDTX)
    {
        oscl_memset(state->mem_syn, 0, sizeof(Word16)*M);
    }
    /* initialize pitch sharpening */
    state->sharp = SHARPMIN;
    state->old_T0 = 40;

    /* Initialize overflow Flag */

    state->overflow = 0;

    /* Initialize state->lsp_old [] */

    if (mode != MRDTX)
    {
        state->lsp_old[0] = 30000;
        state->lsp_old[1] = 26000;
        state->lsp_old[2] = 21000;
        state->lsp_old[3] = 15000;
        state->lsp_old[4] = 8000;
        state->lsp_old[5] = 0;
        state->lsp_old[6] = -8000;
        state->lsp_old[7] = -15000;
        state->lsp_old[8] = -21000;
        state->lsp_old[9] = -26000;
    }

    /* Initialize memories of bad frame handling */
    state->prev_bf = 0;
    state->prev_pdf = 0;
    state->state = 0;

    state->T0_lagBuff = 40;
    state->inBackgroundNoise = 0;
    state->voicedHangover = 0;
    if (mode != MRDTX)
    {
        for (i = 0; i < EXC_ENERGY_HIST_LEN; i++)
        {
            state->excEnergyHist[i] = 0;
        }
    }

    for (i = 0; i < LTP_GAIN_HISTORY_LEN; i++)
    {
        state->ltpGainHistory[i] = 0;
    }

    Cb_gain_average_reset(&(state->Cb_gain_averState));
    if (mode != MRDTX)
    {
        lsp_avg_reset(&(state->lsp_avg_st));
    }
    D_plsf_reset(&(state->lsfState));
    ec_gain_pitch_reset(&(state->ec_gain_p_st));
    ec_gain_code_reset(&(state->ec_gain_c_st));

    if (mode != MRDTX)
    {
        gc_pred_reset(&(state->pred_state));
    }

    Bgn_scd_reset(&(state->background_state));
    state->nodataSeed = 21845;
    ph_disp_reset(&(state->ph_disp_st));
    if (mode != MRDTX)
    {
        dtx_dec_reset(&(state->dtxDecoderState));
    }

    return(0);
}

/****************************************************************************/

/*
------------------------------------------------------------------------------
 FUNCTION NAME: Decoder_amr
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    st = pointer to a structure of type Decoder_amrState
    mode = codec mode (enum Mode)
    parm = buffer of synthesis parameters (Word16)
    frame_type = received frame type (enum RXFrameType)
    synth = buffer containing synthetic speech (Word16)
    A_t = buffer containing decoded LP filter in 4 subframes (Word16)

 Outputs:
    structure pointed to by st contains the newly calculated decoder
      parameters
    synth buffer contains the decoded speech samples
    A_t buffer contains the decoded LP filter parameters

 Returns:
    return_value = 0 (int)

 Global Variables Used:
    None

 Local Variables Needed:
    None

------------------------------------------------------------------------------
 FUNCTION DESCRIPTION

 This function performs the decoding of one speech frame for a given codec
 mode.

------------------------------------------------------------------------------
 REQUIREMENTS

 None

------------------------------------------------------------------------------
 REFERENCES

 dec_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

------------------------------------------------------------------------------
 PSEUDO-CODE

int Decoder_amr (
    Decoder_amrState *st,      // i/o : State variables
    enum Mode mode,            // i   : AMR mode
    Word16 parm[],             // i   : vector of synthesis parameters
                                        (PRM_SIZE)
    enum RXFrameType frame_type, // i   : received frame type
    Word16 synth[],            // o   : synthesis speech (L_FRAME)
    Word16 A_t[]               // o   : decoded LP filter in 4 subframes
                                        (AZ_SIZE)
)
{
    // LPC coefficients

    Word16 *Az;                // Pointer on A_t

    // LSPs

    Word16 lsp_new[M];
    Word16 lsp_mid[M];

    // LSFs

    Word16 prev_lsf[M];
    Word16 lsf_i[M];

    // Algebraic codevector

    Word16 code[L_SUBFR];

    // excitation

    Word16 excp[L_SUBFR];
    Word16 exc_enhanced[L_SUBFR];

    // Scalars

    Word16 i, i_subfr;
    Word16 T0, T0_frac, index, index_mr475 = 0;
    Word16 gain_pit, gain_code, gain_code_mix, pit_sharp, pit_flag, pitch_fac;
    Word16 t0_min, t0_max;
    Word16 delta_frc_low, delta_frc_range;
    Word16 tmp_shift;
    Word16 temp;
    Word32 L_temp;
    Word16 flag4;
    Word16 carefulFlag;
    Word16 excEnergy;
    Word16 subfrNr;
    Word16 evenSubfr = 0;

    Word16 bfi = 0;   // bad frame indication flag
    Word16 pdfi = 0;  // potential degraded bad frame flag

    enum DTXStateType newDTXState;  // SPEECH , DTX, DTX_MUTE

    // find the new  DTX state  SPEECH OR DTX
    newDTXState = rx_dtx_handler(st->dtxDecoderState, frame_type);

    // DTX actions
    if (sub(newDTXState, SPEECH) != 0 )
    {
       Decoder_amr_reset (st, MRDTX);

       dtx_dec(st->dtxDecoderState,
               st->mem_syn,
               st->lsfState,
               st->pred_state,
               st->Cb_gain_averState,
               newDTXState,
               mode,
               parm, synth, A_t);
       // update average lsp

       Lsf_lsp(st->lsfState->past_lsf_q, st->lsp_old, M);
       lsp_avg(st->lsp_avg_st, st->lsfState->past_lsf_q);
       goto the_end;
    }

    // SPEECH action state machine
    if ((sub(frame_type, RX_SPEECH_BAD) == 0) ||
        (sub(frame_type, RX_NO_DATA) == 0) ||
        (sub(frame_type, RX_ONSET) == 0))
    {
       bfi = 1;
       if ((sub(frame_type, RX_NO_DATA) == 0) ||
           (sub(frame_type, RX_ONSET) == 0))
       {
      build_CN_param(&st->nodataSeed,
             prmno[mode],
             bitno[mode],
             parm);
       }
    }
    else if (sub(frame_type, RX_SPEECH_DEGRADED) == 0)
    {
       pdfi = 1;
    }

    if (bfi != 0)
    {
        st->state = add (st->state, 1);
    }
    else if (sub (st->state, 6) == 0)

    {
        st->state = 5;
    }
    else
    {
        st->state = 0;
    }

    if (sub (st->state, 6) > 0)
    {
        st->state = 6;
    }

    // If this frame is the first speech frame after CNI period,
    // set the BFH state machine to an appropriate state depending
    // on whether there was DTX muting before start of speech or not
    // If there was DTX muting, the first speech frame is muted.
    // If there was no DTX muting, the first speech frame is not
    // muted. The BFH state machine starts from state 5, however, to
    // keep the audible noise resulting from a SID frame which is
    // erroneously interpreted as a good speech frame as small as
    // possible (the decoder output in this case is quickly muted)

    if (sub(st->dtxDecoderState->dtxGlobalState, DTX) == 0)
    {
       st->state = 5;
       st->prev_bf = 0;
    }
    else if (sub(st->dtxDecoderState->dtxGlobalState, DTX_MUTE) == 0)
    {
       st->state = 5;
       st->prev_bf = 1;
    }

    // save old LSFs for CB gain smoothing
    Copy (st->lsfState->past_lsf_q, prev_lsf, M);

    // decode LSF parameters and generate interpolated lpc coefficients
       for the 4 subframes
    if (sub (mode, MR122) != 0)
    {
       D_plsf_3(st->lsfState, mode, bfi, parm, lsp_new);

       // Advance synthesis parameters pointer
       parm += 3;

       Int_lpc_1to3(st->lsp_old, lsp_new, A_t);
    }
    else
    {
       D_plsf_5 (st->lsfState, bfi, parm, lsp_mid, lsp_new);

       // Advance synthesis parameters pointer
       parm += 5;

       Int_lpc_1and3 (st->lsp_old, lsp_mid, lsp_new, A_t);
    }

    // update the LSPs for the next frame
    for (i = 0; i < M; i++)
    {
       st->lsp_old[i] = lsp_new[i];
    }

    *------------------------------------------------------------------------*
    *          Loop for every subframe in the analysis frame                 *
    *------------------------------------------------------------------------*
    * The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR  *
    *  times                                                                 *
    *     - decode the pitch delay                                           *
    *     - decode algebraic code                                            *
    *     - decode pitch and codebook gains                                  *
    *     - find the excitation and compute synthesis speech                 *
    *------------------------------------------------------------------------*

    // pointer to interpolated LPC parameters
    Az = A_t;

    evenSubfr = 0;
    subfrNr = -1;
    for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
    {
       subfrNr = add(subfrNr, 1);
       evenSubfr = sub(1, evenSubfr);

       // flag for first and 3th subframe
       pit_flag = i_subfr;

       if (sub (i_subfr, L_FRAME_BY2) == 0)
       {
          if (sub(mode, MR475) != 0 && sub(mode, MR515) != 0)
          {
             pit_flag = 0;
          }
       }

       // pitch index
       index = *parm++;

        *-------------------------------------------------------*
        * - decode pitch lag and find adaptive codebook vector. *
        *-------------------------------------------------------*

       if (sub(mode, MR122) != 0)
       {
          // flag4 indicates encoding with 4 bit resolution;
          // this is needed for mode MR475, MR515, MR59 and MR67

          flag4 = 0;
          if ((sub (mode, MR475) == 0) ||
              (sub (mode, MR515) == 0) ||
              (sub (mode, MR59) == 0) ||
              (sub (mode, MR67) == 0) ) {
             flag4 = 1;
          }

           *-------------------------------------------------------*
           * - get ranges for the t0_min and t0_max                *
           * - only needed in delta decoding                       *
           *-------------------------------------------------------*

          delta_frc_low = 5;
          delta_frc_range = 9;

          if ( sub(mode, MR795) == 0 )
          {
             delta_frc_low = 10;
             delta_frc_range = 19;
          }

          t0_min = sub(st->old_T0, delta_frc_low);
          if (sub(t0_min, PIT_MIN) < 0)
          {
             t0_min = PIT_MIN;
          }
          t0_max = add(t0_min, delta_frc_range);
          if (sub(t0_max, PIT_MAX) > 0)
          {
             t0_max = PIT_MAX;
             t0_min = sub(t0_max, delta_frc_range);
          }

          Dec_lag3 (index, t0_min, t0_max, pit_flag, st->old_T0,
                    &T0, &T0_frac, flag4);

          st->T0_lagBuff = T0;

          if (bfi != 0)
          {
             if (sub (st->old_T0, PIT_MAX) < 0)
             {                                      // Graceful pitch
                st->old_T0 = add(st->old_T0, 1);    // degradation
             }
             T0 = st->old_T0;
             T0_frac = 0;

             if ( st->inBackgroundNoise != 0 &&
                  sub(st->voicedHangover, 4) > 0 &&
                  ((sub(mode, MR475) == 0 ) ||
                   (sub(mode, MR515) == 0 ) ||
                   (sub(mode, MR59) == 0) )
                  )
             {
                T0 = st->T0_lagBuff;
             }
          }

          Pred_lt_3or6 (st->exc, T0, T0_frac, L_SUBFR, 1);
       }
       else
       {
          Dec_lag6 (index, PIT_MIN_MR122,
                    PIT_MAX, pit_flag, &T0, &T0_frac);

          if ( bfi == 0 && (pit_flag == 0 || sub (index, 61) < 0))
          {
          }
          else
          {
             st->T0_lagBuff = T0;
             T0 = st->old_T0;
             T0_frac = 0;
          }

          Pred_lt_3or6 (st->exc, T0, T0_frac, L_SUBFR, 0);
       }

        *-------------------------------------------------------*
        * - (MR122 only: Decode pitch gain.)                    *
        * - Decode innovative codebook.                         *
        * - set pitch sharpening factor                         *
        *-------------------------------------------------------*

        if (sub (mode, MR475) == 0 || sub (mode, MR515) == 0)
        {   // MR475, MR515
           index = *parm++;        // index of position
           i = *parm++;            // signs

           decode_2i40_9bits (subfrNr, i, index, code);

           pit_sharp = shl (st->sharp, 1);
        }
        else if (sub (mode, MR59) == 0)
        {   // MR59
           index = *parm++;        // index of position
           i = *parm++;            // signs

           decode_2i40_11bits (i, index, code);

           pit_sharp = shl (st->sharp, 1);
        }
        else if (sub (mode, MR67) == 0)
        {   // MR67
           index = *parm++;        // index of position
           i = *parm++;            // signs

           decode_3i40_14bits (i, index, code);

           pit_sharp = shl (st->sharp, 1);
        }
        else if (sub (mode, MR795) <= 0)
        {   // MR74, MR795
           index = *parm++;        // index of position
           i = *parm++;            // signs

           decode_4i40_17bits (i, index, code);

           pit_sharp = shl (st->sharp, 1);
        }
        else if (sub (mode, MR102) == 0)
        {  // MR102
           dec_8i40_31bits (parm, code);
           parm += 7;

           pit_sharp = shl (st->sharp, 1);
        }
        else
        {  // MR122
           index = *parm++;
           if (bfi != 0)
           {
              ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit);
           }
           else
           {
              gain_pit = d_gain_pitch (mode, index);
           }
           ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf,
                                 &gain_pit);

           dec_10i40_35bits (parm, code);
           parm += 10;

           // pit_sharp = gain_pit;
           // if (pit_sharp > 1.0) pit_sharp = 1.0;

           pit_sharp = shl (gain_pit, 1);
        }

         *-------------------------------------------------------*
         * - Add the pitch contribution to code[].               *
         *-------------------------------------------------------*
        for (i = T0; i < L_SUBFR; i++)
        {
           temp = mult (code[i - T0], pit_sharp);
           code[i] = add (code[i], temp);
        }

         *------------------------------------------------------------*
         * - Decode codebook gain (MR122) or both pitch               *
         *   gain and codebook gain (all others)                      *
         * - Update pitch sharpening "sharp" with quantized gain_pit  *
         *------------------------------------------------------------*

        if (sub (mode, MR475) == 0)
        {
           // read and decode pitch and code gain
           if (evenSubfr != 0)
           {
              index_mr475 = *parm++; // index of gain(s)
           }

           if (bfi == 0)
           {
              Dec_gain(st->pred_state, mode, index_mr475, code,
                       evenSubfr, &gain_pit, &gain_code);
           }
           else
           {
              ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit);
              ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state,
                            &gain_code);
           }
           ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf,
                                 &gain_pit);
           ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf,
                                &gain_code);

           pit_sharp = gain_pit;
           if (sub (pit_sharp, SHARPMAX) > 0)
           {
               pit_sharp = SHARPMAX;
           }

        }
        else if ((sub (mode, MR74) <= 0) ||
                 (sub (mode, MR102) == 0))
        {
            // read and decode pitch and code gain
            index = *parm++; // index of gain(s)

            if (bfi == 0)
            {
               Dec_gain(st->pred_state, mode, index, code,
                        evenSubfr, &gain_pit, &gain_code);
            }
            else
            {
               ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit);
               ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state,
                             &gain_code);
            }
            ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf,
                                  &gain_pit);
            ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf,
                                 &gain_code);

            pit_sharp = gain_pit;
            if (sub (pit_sharp, SHARPMAX) > 0)
            {
               pit_sharp = SHARPMAX;
            }

            if (sub (mode, MR102) == 0)
            {
               if (sub (st->old_T0, add(L_SUBFR, 5)) > 0)
               {
                  pit_sharp = shr(pit_sharp, 2);
               }
            }
        }
        else
        {
           // read and decode pitch gain
           index = *parm++; // index of gain(s)

           if (sub (mode, MR795) == 0)
           {
              // decode pitch gain
              if (bfi != 0)
              {
                 ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit);
              }
              else
              {
                 gain_pit = d_gain_pitch (mode, index);
              }
              ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf,
                                    &gain_pit);

              // read and decode code gain
              index = *parm++;
              if (bfi == 0)
              {
                 d_gain_code (st->pred_state, mode, index, code, &gain_code);
              }
              else
              {
                 ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state,
                               &gain_code);
              }
              ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf,
                                   &gain_code);

              pit_sharp = gain_pit;
              if (sub (pit_sharp, SHARPMAX) > 0)
              {
                 pit_sharp = SHARPMAX;
              }
           }
           else
           { // MR122
              if (bfi == 0)
              {
                 d_gain_code (st->pred_state, mode, index, code, &gain_code);
              }
              else
              {
                 ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state,
                               &gain_code);
              }
              ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf,
                                   &gain_code);

              pit_sharp = gain_pit;
           }
        }

        // store pitch sharpening for next subframe
        // (for modes which use the previous pitch gain for
        // pitch sharpening in the search phase)
        // do not update sharpening in even subframes for MR475
        if (sub(mode, MR475) != 0 || evenSubfr == 0)
        {
            st->sharp = gain_pit;
            if (sub (st->sharp, SHARPMAX) > 0)
            {
                st->sharp = SHARPMAX;
            }
        }

        pit_sharp = shl (pit_sharp, 1);
        if (sub (pit_sharp, 16384) > 0)
        {
           for (i = 0; i < L_SUBFR; i++)
            {
               temp = mult (st->exc[i], pit_sharp);
               L_temp = L_mult (temp, gain_pit);
               if (sub(mode, MR122)==0)
               {
                  L_temp = L_shr (L_temp, 1);
               }
               excp[i] = pv_round (L_temp);
            }
        }

         *-------------------------------------------------------*
         * - Store list of LTP gains needed in the source        *
         *   characteristic detector (SCD)                       *
         *-------------------------------------------------------*
        if ( bfi == 0 )
        {
           for (i = 0; i < 8; i++)
           {
              st->ltpGainHistory[i] = st->ltpGainHistory[i+1];
           }
           st->ltpGainHistory[8] = gain_pit;
        }

         *-------------------------------------------------------*
         * - Limit gain_pit if in background noise and BFI       *
         *   for MR475, MR515, MR59                              *
         *-------------------------------------------------------*

        if ( (st->prev_bf != 0 || bfi != 0) && st->inBackgroundNoise != 0 &&
             ((sub(mode, MR475) == 0) ||
              (sub(mode, MR515) == 0) ||
              (sub(mode, MR59) == 0))
             )
        {
           if ( sub (gain_pit, 12288) > 0)    // if (gain_pit > 0.75) in Q14
              gain_pit = add( shr( sub(gain_pit, 12288), 1 ), 12288 );
              // gain_pit = (gain_pit-0.75)/2.0 + 0.75;

           if ( sub (gain_pit, 14745) > 0)    // if (gain_pit > 0.90) in Q14
           {
              gain_pit = 14745;
           }
        }

         *-------------------------------------------------------*
         *  Calculate CB mixed gain                              *
         *-------------------------------------------------------*
        Int_lsf(prev_lsf, st->lsfState->past_lsf_q, i_subfr, lsf_i);
        gain_code_mix = Cb_gain_average(
            st->Cb_gain_averState, mode, gain_code,
            lsf_i, st->lsp_avg_st->lsp_meanSave, bfi,
            st->prev_bf, pdfi, st->prev_pdf,
            st->inBackgroundNoise, st->voicedHangover);

        // make sure that MR74, MR795, MR122 have original code_gain
        if ((sub(mode, MR67) > 0) && (sub(mode, MR102) != 0) )
           // MR74, MR795, MR122
        {
           gain_code_mix = gain_code;
        }

         *-------------------------------------------------------*
         * - Find the total excitation.                          *
         * - Find synthesis speech corresponding to st->exc[].   *
         *-------------------------------------------------------*
        if (sub(mode, MR102) <= 0) // MR475, MR515, MR59, MR67, MR74, MR795, MR102
        {
           pitch_fac = gain_pit;
           tmp_shift = 1;
        }
        else       // MR122
        {
           pitch_fac = shr (gain_pit, 1);
           tmp_shift = 2;
        }

        // copy unscaled LTP excitation to exc_enhanced (used in phase
         * dispersion below) and compute total excitation for LTP feedback

        for (i = 0; i < L_SUBFR; i++)
        {
           exc_enhanced[i] = st->exc[i];

           // st->exc[i] = gain_pit*st->exc[i] + gain_code*code[i];
           L_temp = L_mult (st->exc[i], pitch_fac);
                                                      // 12.2: Q0 * Q13
                                                      //  7.4: Q0 * Q14
           L_temp = L_mac (L_temp, code[i], gain_code);
                                                      // 12.2: Q12 * Q1
                                                      //  7.4: Q13 * Q1
           L_temp = L_shl (L_temp, tmp_shift);                   // Q16
           st->exc[i] = pv_round (L_temp);
        }

         *-------------------------------------------------------*
         * - Adaptive phase dispersion                           *
         *-------------------------------------------------------*
        ph_disp_release(st->ph_disp_st); // free phase dispersion adaption

        if ( ((sub(mode, MR475) == 0) ||
              (sub(mode, MR515) == 0) ||
              (sub(mode, MR59) == 0))   &&
             sub(st->voicedHangover, 3) > 0 &&
             st->inBackgroundNoise != 0 &&
             bfi != 0 )
        {
           ph_disp_lock(st->ph_disp_st); // Always Use full Phase Disp.
        }                                // if error in bg noise

        // apply phase dispersion to innovation (if enabled) and
           compute total excitation for synthesis part
        ph_disp(st->ph_disp_st, mode,
                exc_enhanced, gain_code_mix, gain_pit, code,
                pitch_fac, tmp_shift);

         *-------------------------------------------------------*
         * - The Excitation control module are active during BFI.*
         * - Conceal drops in signal energy if in bg noise.      *
         *-------------------------------------------------------*

        L_temp = 0;
        for (i = 0; i < L_SUBFR; i++)
        {
            L_temp = L_mac (L_temp, exc_enhanced[i], exc_enhanced[i] );
        }

        L_temp = L_shr (L_temp, 1);     // excEnergy = sqrt(L_temp) in Q0
        L_temp = sqrt_l_exp(L_temp, &temp); // function result
        L_temp = L_shr(L_temp, add( shr(temp, 1), 15));
        L_temp = L_shr(L_temp, 2);       // To cope with 16-bit and
        excEnergy = extract_l(L_temp);   // scaling in ex_ctrl()

        if ( ((sub (mode, MR475) == 0) ||
              (sub (mode, MR515) == 0) ||
              (sub (mode, MR59) == 0))  &&
             sub(st->voicedHangover, 5) > 0 &&
             st->inBackgroundNoise != 0 &&
             sub(st->state, 4) < 0 &&
             ( (pdfi != 0 && st->prev_pdf != 0) ||
                bfi != 0 ||
                st->prev_bf != 0) )
        {
           carefulFlag = 0;
           if ( pdfi != 0 && bfi == 0 )
           {
              carefulFlag = 1;
           }

           Ex_ctrl(exc_enhanced,
                   excEnergy,
                   st->excEnergyHist,
                   st->voicedHangover,
                   st->prev_bf,
                   carefulFlag);
        }

        if ( st->inBackgroundNoise != 0 &&
             ( bfi != 0 || st->prev_bf != 0 ) &&
             sub(st->state, 4) < 0 )
        {
           ; // do nothing!
        }
        else
        {
           // Update energy history for all modes
           for (i = 0; i < 8; i++)
           {
              st->excEnergyHist[i] = st->excEnergyHist[i+1];
           }
           st->excEnergyHist[8] = excEnergy;
        }
         *-------------------------------------------------------*
         * Excitation control module end.                        *
         *-------------------------------------------------------*

        if (sub (pit_sharp, 16384) > 0)
        {
           for (i = 0; i < L_SUBFR; i++)
           {
              excp[i] = add (excp[i], exc_enhanced[i]);
           }
           agc2 (exc_enhanced, excp, L_SUBFR);
           Overflow = 0;
           Syn_filt (Az, excp, &synth[i_subfr], L_SUBFR,
                     st->mem_syn, 0);
        }
        else
        {
           Overflow = 0;
           Syn_filt (Az, exc_enhanced, &synth[i_subfr], L_SUBFR,
                     st->mem_syn, 0);
        }

        if (Overflow != 0)    // Test for overflow
        {
           for (i = 0; i < PIT_MAX + L_INTERPOL + L_SUBFR; i++)
           {
              st->old_exc[i] = shr(st->old_exc[i], 2);
           }
           for (i = 0; i < L_SUBFR; i++)
           {
              exc_enhanced[i] = shr(exc_enhanced[i], 2);
           }
           Syn_filt(Az, exc_enhanced, &synth[i_subfr], L_SUBFR, st->mem_syn, 1);
        }
        else
        {
           Copy(&synth[i_subfr+L_SUBFR-M], st->mem_syn, M);
        }

         *--------------------------------------------------*
         * Update signal for next frame.                    *
         * -> shift to the left by L_SUBFR  st->exc[]       *
         *--------------------------------------------------*

        Copy (&st->old_exc[L_SUBFR], &st->old_exc[0], PIT_MAX + L_INTERPOL);

        // interpolated LPC parameters for next subframe
        Az += MP1;

        // store T0 for next subframe
        st->old_T0 = T0;
    }

     *-------------------------------------------------------*
     * Call the Source Characteristic Detector which updates *
     * st->inBackgroundNoise and st->voicedHangover.         *
     *-------------------------------------------------------*

    st->inBackgroundNoise = Bgn_scd(st->background_state,
                                    &(st->ltpGainHistory[0]),
                                    &(synth[0]),
                                    &(st->voicedHangover) );

    dtx_dec_activity_update(st->dtxDecoderState,
                            st->lsfState->past_lsf_q,
                            synth);

    // store bfi for next subframe
    st->prev_bf = bfi;
    st->prev_pdf = pdfi;

     *--------------------------------------------------*
     * Calculate the LSF averages on the eight          *
     * previous frames                                  *
     *--------------------------------------------------*

    lsp_avg(st->lsp_avg_st, st->lsfState->past_lsf_q);

the_end:
    st->dtxDecoderState->dtxGlobalState = newDTXState;

    return 0;
}

------------------------------------------------------------------------------
 RESOURCES USED [optional]

 When the code is written for a specific target processor the
 the resources used should be documented below.

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

 CLOCK CYCLES: (cycle count equation for this function) + (variable
                used to represent cycle count for each subroutine
                called)
     where: (cycle count variable) = cycle count for [subroutine
                                     name]

------------------------------------------------------------------------------
 CAUTION [optional]
 [State any special notes, constraints or cautions for users of this function]

------------------------------------------------------------------------------
*/

void Decoder_amr(
    Decoder_amrState *st,      /* i/o : State variables                   */
    enum Mode mode,            /* i   : AMR mode                          */
    Word16 parm[],             /* i   : vector of synthesis parameters
                                        (PRM_SIZE)                        */
    enum RXFrameType frame_type, /* i   : received frame type             */
    Word16 synth[],            /* o   : synthesis speech (L_FRAME)        */
    Word16 A_t[]               /* o   : decoded LP filter in 4 subframes
                                        (AZ_SIZE)                         */
)
{
    /* LPC coefficients */

    Word16 *Az;                /* Pointer on A_t */

    /* LSPs */

    Word16 lsp_new[M];
    Word16 lsp_mid[M];

    /* LSFs */

    Word16 prev_lsf[M];
    Word16 lsf_i[M];

    /* Algebraic codevector */

    Word16 code[L_SUBFR];

    /* excitation */

    Word16 excp[L_SUBFR];
    Word16 exc_enhanced[L_SUBFR];

    /* Scalars */

    Word16 i;
    Word16 i_subfr;
    Word16 T0;
    Word16 T0_frac;
    Word16 index;
    Word16 index_mr475 = 0;
    Word16 gain_pit;
    Word16 gain_code;
    Word16 gain_code_mix;
    Word16 pit_sharp;
    Word16 pit_flag;
    Word16 pitch_fac;
    Word16 t0_min;
    Word16 t0_max;
    Word16 delta_frc_low;
    Word16 delta_frc_range;
    Word16 tmp_shift;
    Word16 temp;
    Word32 L_temp;
    Word16 flag4;
    Word16 carefulFlag;
    Word16 excEnergy;
    Word16 subfrNr;
    Word16 evenSubfr = 0;

    Word16 bfi = 0;   /* bad frame indication flag                          */
    Word16 pdfi = 0;  /* potential degraded bad frame flag                  */

    enum DTXStateType newDTXState;  /* SPEECH , DTX, DTX_MUTE */
    Flag   *pOverflow = &(st->overflow);     /* Overflow flag            */


    /* find the new  DTX state  SPEECH OR DTX */
    newDTXState = rx_dtx_handler(&(st->dtxDecoderState), frame_type, pOverflow);

    /* DTX actions */

    if (newDTXState != SPEECH)
    {
        Decoder_amr_reset(st, MRDTX);

        dtx_dec(&(st->dtxDecoderState),
                st->mem_syn,
                &(st->lsfState),
                &(st->pred_state),
                &(st->Cb_gain_averState),
                newDTXState,
                mode,
                parm, synth, A_t, pOverflow);

        /* update average lsp */
        Lsf_lsp(
            st->lsfState.past_lsf_q,
            st->lsp_old,
            M,
            pOverflow);

        lsp_avg(
            &(st->lsp_avg_st),
            st->lsfState.past_lsf_q,
            pOverflow);

        goto the_end;
    }

    /* SPEECH action state machine  */
    if ((frame_type == RX_SPEECH_BAD) || (frame_type == RX_NO_DATA) ||
            (frame_type == RX_ONSET))
    {
        bfi = 1;

        if ((frame_type == RX_NO_DATA) || (frame_type == RX_ONSET))
        {
            build_CN_param(&st->nodataSeed,
                           prmno[mode],
                           bitno[mode],
                           parm,
                           pOverflow);
        }
    }
    else if (frame_type == RX_SPEECH_DEGRADED)
    {
        pdfi = 1;
    }

    if (bfi != 0)
    {
        st->state += 1;
    }
    else if (st->state == 6)

    {
        st->state = 5;
    }
    else
    {
        st->state = 0;
    }


    if (st->state > 6)
    {
        st->state = 6;
    }

    /* If this frame is the first speech frame after CNI period,     */
    /* set the BFH state machine to an appropriate state depending   */
    /* on whether there was DTX muting before start of speech or not */
    /* If there was DTX muting, the first speech frame is muted.     */
    /* If there was no DTX muting, the first speech frame is not     */
    /* muted. The BFH state machine starts from state 5, however, to */
    /* keep the audible noise resulting from a SID frame which is    */
    /* erroneously interpreted as a good speech frame as small as    */
    /* possible (the decoder output in this case is quickly muted)   */

    if (st->dtxDecoderState.dtxGlobalState == DTX)
    {
        st->state = 5;
        st->prev_bf = 0;
    }
    else if (st->dtxDecoderState.dtxGlobalState == DTX_MUTE)
    {
        st->state = 5;
        st->prev_bf = 1;
    }

    /* save old LSFs for CB gain smoothing */
    Copy(st->lsfState.past_lsf_q, prev_lsf, M);

    /* decode LSF parameters and generate interpolated lpc coefficients
       for the 4 subframes */

    if (mode != MR122)
    {
        D_plsf_3(
            &(st->lsfState),
            mode,
            bfi,
            parm,
            lsp_new,
            pOverflow);

        /* Advance synthesis parameters pointer */
        parm += 3;

        Int_lpc_1to3(
            st->lsp_old,
            lsp_new,
            A_t,
            pOverflow);
    }
    else
    {
        D_plsf_5(
            &(st->lsfState),
            bfi,
            parm,
            lsp_mid,
            lsp_new,
            pOverflow);

        /* Advance synthesis parameters pointer */
        parm += 5;

        Int_lpc_1and3(
            st->lsp_old,
            lsp_mid,
            lsp_new,
            A_t,
            pOverflow);
    }

    /* update the LSPs for the next frame */
    for (i = 0; i < M; i++)
    {
        st->lsp_old[i] = lsp_new[i];
    }

    /*------------------------------------------------------------------------*
     *          Loop for every subframe in the analysis frame                 *
     *------------------------------------------------------------------------*
     * The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR  *
     *  times                                                                 *
     *     - decode the pitch delay                                           *
     *     - decode algebraic code                                            *
     *     - decode pitch and codebook gains                                  *
     *     - find the excitation and compute synthesis speech                 *
     *------------------------------------------------------------------------*/

    /* pointer to interpolated LPC parameters */
    Az = A_t;

    evenSubfr = 0;
    subfrNr = -1;
    for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
    {
        subfrNr += 1;
        evenSubfr = 1 - evenSubfr;

        /* flag for first and 3th subframe */
        pit_flag = i_subfr;


        if (i_subfr == L_FRAME_BY2)
        {
            if ((mode != MR475) && (mode != MR515))
            {
                pit_flag = 0;
            }
        }

        /* pitch index */
        index = *parm++;

        /*-------------------------------------------------------*
        * - decode pitch lag and find adaptive codebook vector. *
        *-------------------------------------------------------*/

        if (mode != MR122)
        {
            /* flag4 indicates encoding with 4 bit resolution;     */
            /* this is needed for mode MR475, MR515, MR59 and MR67 */

            flag4 = 0;

            if ((mode == MR475) || (mode == MR515) || (mode == MR59) ||
                    (mode == MR67))
            {
                flag4 = 1;
            }

            /*-------------------------------------------------------*
            * - get ranges for the t0_min and t0_max                *
            * - only needed in delta decoding                       *
            *-------------------------------------------------------*/

            delta_frc_low = 5;
            delta_frc_range = 9;

            if (mode == MR795)
            {
                delta_frc_low = 10;
                delta_frc_range = 19;
            }

            t0_min = sub(st->old_T0, delta_frc_low, pOverflow);

            if (t0_min < PIT_MIN)
            {
                t0_min = PIT_MIN;
            }
            t0_max = add(t0_min, delta_frc_range, pOverflow);

            if (t0_max > PIT_MAX)
            {
                t0_max = PIT_MAX;
                t0_min = t0_max - delta_frc_range;
            }

            Dec_lag3(index, t0_min, t0_max, pit_flag, st->old_T0,
                     &T0, &T0_frac, flag4, pOverflow);

            st->T0_lagBuff = T0;

            if (bfi != 0)
            {
                if (st->old_T0 < PIT_MAX)
                {                               /* Graceful pitch */
                    st->old_T0 += 1;            /* degradation    */
                }
                T0 = st->old_T0;
                T0_frac = 0;

                if ((st->inBackgroundNoise != 0) && (st->voicedHangover > 4) &&
                        ((mode == MR475) || (mode == MR515) || (mode == MR59)))
                {
                    T0 = st->T0_lagBuff;
                }
            }

            Pred_lt_3or6(st->exc, T0, T0_frac, L_SUBFR, 1, pOverflow);
        }
        else
        {
            Dec_lag6(index, PIT_MIN_MR122,
                     PIT_MAX, pit_flag, &T0, &T0_frac, pOverflow);


            if (!(bfi == 0 && (pit_flag == 0 || index < 61)))
            {
                st->T0_lagBuff = T0;
                T0 = st->old_T0;
                T0_frac = 0;
            }

            Pred_lt_3or6(st->exc, T0, T0_frac, L_SUBFR, 0, pOverflow);
        }

        /*-------------------------------------------------------*
         * - (MR122 only: Decode pitch gain.)                    *
         * - Decode innovative codebook.                         *
         * - set pitch sharpening factor                         *
         *-------------------------------------------------------*/
        if ((mode == MR475) || (mode == MR515))
        {   /* MR475, MR515 */
            index = *parm++;        /* index of position */
            i = *parm++;            /* signs             */

            decode_2i40_9bits(subfrNr, i, index, code, pOverflow);

            L_temp = (Word32)st->sharp << 1;
            if (L_temp != (Word32)((Word16) L_temp))
            {
                pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16;
            }
            else
            {
                pit_sharp = (Word16) L_temp;
            }
        }
        else if (mode == MR59)
        {   /* MR59 */
            index = *parm++;        /* index of position */
            i = *parm++;            /* signs             */

            decode_2i40_11bits(i, index, code);

            L_temp = (Word32)st->sharp << 1;
            if (L_temp != (Word32)((Word16) L_temp))
            {
                pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16;
            }
            else
            {
                pit_sharp = (Word16) L_temp;
            }
        }
        else if (mode == MR67)
        {   /* MR67 */
            index = *parm++;        /* index of position */
            i = *parm++;            /* signs             */

            decode_3i40_14bits(i, index, code);

            L_temp = (Word32)st->sharp << 1;
            if (L_temp != (Word32)((Word16) L_temp))
            {
                pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16;
            }
            else
            {
                pit_sharp = (Word16) L_temp;
            }
        }
        else if (mode <= MR795)
        {   /* MR74, MR795 */
            index = *parm++;        /* index of position */
            i = *parm++;            /* signs             */

            decode_4i40_17bits(i, index, code);

            L_temp = (Word32)st->sharp << 1;
            if (L_temp != (Word32)((Word16) L_temp))
            {
                pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16;
            }
            else
            {
                pit_sharp = (Word16) L_temp;
            }
        }
        else if (mode == MR102)
        {  /* MR102 */
            dec_8i40_31bits(parm, code, pOverflow);
            parm += 7;

            L_temp = (Word32)st->sharp << 1;
            if (L_temp != (Word32)((Word16) L_temp))
            {
                pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16;
            }
            else
            {
                pit_sharp = (Word16) L_temp;
            }
        }
        else
        {  /* MR122 */
            index = *parm++;

            if (bfi != 0)
            {
                ec_gain_pitch(
                    &(st->ec_gain_p_st),
                    st->state,
                    &gain_pit,
                    pOverflow);
            }
            else
            {
                gain_pit = d_gain_pitch(mode, index);
            }
            ec_gain_pitch_update(
                &(st->ec_gain_p_st),
                bfi,
                st->prev_bf,
                &gain_pit,
                pOverflow);


            dec_10i40_35bits(parm, code);
            parm += 10;

            /* pit_sharp = gain_pit;                   */
            /* if (pit_sharp > 1.0) pit_sharp = 1.0;   */

            L_temp = (Word32)gain_pit << 1;
            if (L_temp != (Word32)((Word16) L_temp))
            {
                pit_sharp = (gain_pit > 0) ? MAX_16 : MIN_16;
            }
            else
            {
                pit_sharp = (Word16) L_temp;
            }
        }
        /*-------------------------------------------------------*
         * - Add the pitch contribution to code[].               *
         *-------------------------------------------------------*/
        for (i = T0; i < L_SUBFR; i++)
        {
            temp = mult(*(code + i - T0), pit_sharp, pOverflow);
            *(code + i) = add(*(code + i), temp, pOverflow);

        }

        /*------------------------------------------------------------*
         * - Decode codebook gain (MR122) or both pitch               *
         *   gain and codebook gain (all others)                      *
         * - Update pitch sharpening "sharp" with quantized gain_pit  *
         *------------------------------------------------------------*/
        if (mode == MR475)
        {
            /* read and decode pitch and code gain */

            if (evenSubfr != 0)
            {
                index_mr475 = *parm++;         /* index of gain(s) */
            }

            if (bfi == 0)
            {
                Dec_gain(
                    &(st->pred_state),
                    mode,
                    index_mr475,
                    code,
                    evenSubfr,
                    &gain_pit,
                    &gain_code,
                    pOverflow);
            }
            else
            {
                ec_gain_pitch(
                    &(st->ec_gain_p_st),
                    st->state,
                    &gain_pit,
                    pOverflow);

                ec_gain_code(
                    &(st->ec_gain_c_st),
                    &(st->pred_state),
                    st->state,
                    &gain_code,
                    pOverflow);
            }
            ec_gain_pitch_update(
                &st->ec_gain_p_st,
                bfi,
                st->prev_bf,
                &gain_pit,
                pOverflow);

            ec_gain_code_update(
                &st->ec_gain_c_st,
                bfi,
                st->prev_bf,
                &gain_code,
                pOverflow);

            pit_sharp = gain_pit;

            if (pit_sharp > SHARPMAX)
            {
                pit_sharp = SHARPMAX;
            }

        }
        else if ((mode <= MR74) || (mode == MR102))
        {
            /* read and decode pitch and code gain */
            index = *parm++;                 /* index of gain(s) */

            if (bfi == 0)
            {
                Dec_gain(
                    &(st->pred_state),
                    mode,
                    index,
                    code,
                    evenSubfr,
                    &gain_pit,
                    &gain_code,
                    pOverflow);
            }
            else
            {
                ec_gain_pitch(
                    &(st->ec_gain_p_st),
                    st->state,
                    &gain_pit,
                    pOverflow);

                ec_gain_code(
                    &(st->ec_gain_c_st),
                    &(st->pred_state),
                    st->state,
                    &gain_code,
                    pOverflow);
            }

            ec_gain_pitch_update(
                &(st->ec_gain_p_st),
                bfi,
                st->prev_bf,
                &gain_pit,
                pOverflow);

            ec_gain_code_update(
                &(st->ec_gain_c_st),
                bfi,
                st->prev_bf,
                &gain_code,
                pOverflow);

            pit_sharp = gain_pit;

            if (pit_sharp > SHARPMAX)
            {
                pit_sharp = SHARPMAX;
            }

            if (mode == MR102)
            {
                if (st->old_T0 > (L_SUBFR + 5))
                {
                    if (pit_sharp < 0)
                    {
                        pit_sharp = ~((~pit_sharp) >> 2);
                    }
                    else
                    {
                        pit_sharp = pit_sharp >> 2;
                    }
                }
            }
        }
        else
        {
            /* read and decode pitch gain */
            index = *parm++;                 /* index of gain(s) */

            if (mode == MR795)
            {
                /* decode pitch gain */
                if (bfi != 0)
                {
                    ec_gain_pitch(
                        &(st->ec_gain_p_st),
                        st->state,
                        &gain_pit,
                        pOverflow);
                }
                else
                {
                    gain_pit = d_gain_pitch(mode, index);
                }
                ec_gain_pitch_update(
                    &(st->ec_gain_p_st),
                    bfi,
                    st->prev_bf,
                    &gain_pit,
                    pOverflow);

                /* read and decode code gain */
                index = *parm++;

                if (bfi == 0)
                {
                    d_gain_code(
                        &(st->pred_state),
                        mode,
                        index,
                        code,
                        &gain_code,
                        pOverflow);
                }
                else
                {
                    ec_gain_code(
                        &(st->ec_gain_c_st),
                        &(st->pred_state),
                        st->state,
                        &gain_code,
                        pOverflow);
                }

                ec_gain_code_update(
                    &(st->ec_gain_c_st),
                    bfi,
                    st->prev_bf,
                    &gain_code,
                    pOverflow);

                pit_sharp = gain_pit;

                if (pit_sharp > SHARPMAX)
                {
                    pit_sharp = SHARPMAX;
                }
            }
            else
            { /* MR122 */

                if (bfi == 0)
                {
                    d_gain_code(
                        &(st->pred_state),
                        mode,
                        index,
                        code,
                        &gain_code,
                        pOverflow);
                }
                else
                {
                    ec_gain_code(
                        &(st->ec_gain_c_st),
                        &(st->pred_state),
                        st->state,
                        &gain_code,
                        pOverflow);
                }

                ec_gain_code_update(
                    &(st->ec_gain_c_st),
                    bfi,
                    st->prev_bf,
                    &gain_code,
                    pOverflow);

                pit_sharp = gain_pit;
            }
        }

        /* store pitch sharpening for next subframe             */
        /* (for modes which use the previous pitch gain for     */
        /* pitch sharpening in the search phase)                */
        /* do not update sharpening in even subframes for MR475 */
        if ((mode != MR475) || (evenSubfr == 0))
        {
            st->sharp = gain_pit;

            if (st->sharp > SHARPMAX)
            {
                st->sharp = SHARPMAX;
            }
        }

        pit_sharp = shl(pit_sharp, 1, pOverflow);

        if (pit_sharp > 16384)
        {
            for (i = 0; i < L_SUBFR; i++)
            {
                temp = mult(st->exc[i], pit_sharp, pOverflow);
                L_temp = L_mult(temp, gain_pit, pOverflow);

                if (mode == MR122)
                {
                    if (L_temp < 0)
                    {
                        L_temp = ~((~L_temp) >> 1);
                    }
                    else
                    {
                        L_temp = L_temp >> 1;
                    }
                }
                *(excp + i) = pv_round(L_temp, pOverflow);
            }
        }

        /*-------------------------------------------------------*
         * - Store list of LTP gains needed in the source        *
         *   characteristic detector (SCD)                       *
         *-------------------------------------------------------*/

        if (bfi == 0)
        {
            for (i = 0; i < 8; i++)
            {
                st->ltpGainHistory[i] = st->ltpGainHistory[i+1];
            }
            st->ltpGainHistory[8] = gain_pit;
        }

        /*-------------------------------------------------------*
        * - Limit gain_pit if in background noise and BFI       *
        *   for MR475, MR515, MR59                              *
        *-------------------------------------------------------*/


        if ((st->prev_bf != 0 || bfi != 0) && st->inBackgroundNoise != 0 &&
                ((mode == MR475) || (mode == MR515) || (mode == MR59)))
        {

            if (gain_pit > 12288)    /* if (gain_pit > 0.75) in Q14*/
            {
                gain_pit = ((gain_pit - 12288) >> 1) + 12288;
                /* gain_pit = (gain_pit-0.75)/2.0 + 0.75; */
            }

            if (gain_pit > 14745)    /* if (gain_pit > 0.90) in Q14*/
            {
                gain_pit = 14745;
            }
        }

        /*-------------------------------------------------------*
         *  Calculate CB mixed gain                              *
         *-------------------------------------------------------*/
        Int_lsf(
            prev_lsf,
            st->lsfState.past_lsf_q,
            i_subfr,
            lsf_i,
            pOverflow);

        gain_code_mix =
            Cb_gain_average(
                &(st->Cb_gain_averState),
                mode,
                gain_code,
                lsf_i,
                st->lsp_avg_st.lsp_meanSave,
                bfi,
                st->prev_bf,
                pdfi,
                st->prev_pdf,
                st->inBackgroundNoise,
                st->voicedHangover,
                pOverflow);

        /* make sure that MR74, MR795, MR122 have original code_gain*/
        if ((mode > MR67) && (mode != MR102))
            /* MR74, MR795, MR122 */
        {
            gain_code_mix = gain_code;
        }

        /*-------------------------------------------------------*
         * - Find the total excitation.                          *
         * - Find synthesis speech corresponding to st->exc[].   *
         *-------------------------------------------------------*/
        if (mode <= MR102) /* MR475, MR515, MR59, MR67, MR74, MR795, MR102*/
        {
            pitch_fac = gain_pit;
            tmp_shift = 1;
        }
        else       /* MR122 */
        {
            if (gain_pit < 0)
            {
                pitch_fac = ~((~gain_pit) >> 1);
            }
            else
            {
                pitch_fac = gain_pit >> 1;
            }
            tmp_shift = 2;
        }

        /* copy unscaled LTP excitation to exc_enhanced (used in phase
         * dispersion below) and compute total excitation for LTP feedback
         */
        for (i = 0; i < L_SUBFR; i++)
        {
            exc_enhanced[i] = st->exc[i];

            /* st->exc[i] = gain_pit*st->exc[i] + gain_code*code[i]; */
            L_temp = L_mult(st->exc[i], pitch_fac, pOverflow);
            /* 12.2: Q0 * Q13 */
            /*  7.4: Q0 * Q14 */
            L_temp = L_mac(L_temp, code[i], gain_code, pOverflow);
            /* 12.2: Q12 * Q1 */
            /*  7.4: Q13 * Q1 */
            L_temp = L_shl(L_temp, tmp_shift, pOverflow);     /* Q16 */
            st->exc[i] = pv_round(L_temp, pOverflow);
        }

        /*-------------------------------------------------------*
         * - Adaptive phase dispersion                           *
         *-------------------------------------------------------*/
        ph_disp_release(&(st->ph_disp_st)); /* free phase dispersion adaption */


        if (((mode == MR475) || (mode == MR515) || (mode == MR59)) &&
                (st->voicedHangover > 3) && (st->inBackgroundNoise != 0) &&
                (bfi != 0))
        {
            ph_disp_lock(&(st->ph_disp_st)); /* Always Use full Phase Disp. */
        }                                 /* if error in bg noise       */

        /* apply phase dispersion to innovation (if enabled) and
           compute total excitation for synthesis part           */
        ph_disp(
            &(st->ph_disp_st),
            mode,
            exc_enhanced,
            gain_code_mix,
            gain_pit,
            code,
            pitch_fac,
            tmp_shift,
            pOverflow);

        /*-------------------------------------------------------*
         * - The Excitation control module are active during BFI.*
         * - Conceal drops in signal energy if in bg noise.      *
         *-------------------------------------------------------*/
        L_temp = 0;
        for (i = 0; i < L_SUBFR; i++)
        {
            L_temp = L_mac(L_temp, *(exc_enhanced + i), *(exc_enhanced + i), pOverflow);
        }

        /* excEnergy = sqrt(L_temp) in Q0 */
        if (L_temp < 0)
        {
            L_temp = ~((~L_temp) >> 1);
        }
        else
        {
            L_temp = L_temp >> 1;
        }

        L_temp = sqrt_l_exp(L_temp, &temp, pOverflow);
        /* To cope with 16-bit and scaling in ex_ctrl() */
        L_temp = L_shr(L_temp, (Word16)((temp >> 1) + 15), pOverflow);
        if (L_temp < 0)
        {
            excEnergy = (Word16)(~((~L_temp) >> 2));
        }
        else
        {
            excEnergy = (Word16)(L_temp >> 2);
        }

        if (((mode == MR475) || (mode == MR515) || (mode == MR59))  &&
                (st->voicedHangover > 5) && (st->inBackgroundNoise != 0) &&
                (st->state < 4) &&
                ((pdfi != 0 && st->prev_pdf != 0) || bfi != 0 || st->prev_bf != 0))
        {
            carefulFlag = 0;

            if (pdfi != 0 && bfi == 0)
            {
                carefulFlag = 1;
            }

            Ex_ctrl(exc_enhanced,
                    excEnergy,
                    st->excEnergyHist,
                    st->voicedHangover,
                    st->prev_bf,
                    carefulFlag, pOverflow);
        }

        if (!((st->inBackgroundNoise != 0) && (bfi != 0 || st->prev_bf != 0) &&
                (st->state < 4)))
        {
            /* Update energy history for all modes */
            for (i = 0; i < 8; i++)
            {
                st->excEnergyHist[i] = st->excEnergyHist[i+1];
            }
            st->excEnergyHist[8] = excEnergy;
        }
        /*-------------------------------------------------------*
         * Excitation control module end.                        *
         *-------------------------------------------------------*/
        if (pit_sharp > 16384)
        {
            for (i = 0; i < L_SUBFR; i++)
            {
                *(excp + i) = add(*(excp + i), *(exc_enhanced + i), pOverflow);

            }
            agc2(exc_enhanced, excp, L_SUBFR, pOverflow);
            *pOverflow = 0;
            Syn_filt(Az, excp, &synth[i_subfr], L_SUBFR,
                     st->mem_syn, 0);
        }
        else
        {
            *pOverflow = 0;
            Syn_filt(Az, exc_enhanced, &synth[i_subfr], L_SUBFR,
                     st->mem_syn, 0);
        }

        if (*pOverflow != 0)    /* Test for overflow */
        {
            for (i = PIT_MAX + L_INTERPOL + L_SUBFR - 1; i >= 0; i--)
            {
                if (st->old_exc[i] < 0)
                {
                    st->old_exc[i] = ~((~st->old_exc[i]) >> 2);
                }
                else
                {
                    st->old_exc[i] = st->old_exc[i] >> 2;
                }

            }

            for (i = L_SUBFR - 1; i >= 0; i--)
            {
                if (*(exc_enhanced + i) < 0)
                {
                    *(exc_enhanced + i) = ~((~(*(exc_enhanced + i))) >> 2);
                }
                else
                {
                    *(exc_enhanced + i) = *(exc_enhanced + i) >> 2;
                }
            }
            Syn_filt(Az, exc_enhanced, &synth[i_subfr], L_SUBFR, st->mem_syn, 1);
        }
        else
        {
            Copy(&synth[i_subfr+L_SUBFR-M], st->mem_syn, M);
        }

        /*--------------------------------------------------*
         * Update signal for next frame.                    *
         * -> shift to the left by L_SUBFR  st->exc[]       *
         *--------------------------------------------------*/

        Copy(&st->old_exc[L_SUBFR], &st->old_exc[0], PIT_MAX + L_INTERPOL);

        /* interpolated LPC parameters for next subframe */
        Az += MP1;

        /* store T0 for next subframe */
        st->old_T0 = T0;
    }

    /*-------------------------------------------------------*
     * Call the Source Characteristic Detector which updates *
     * st->inBackgroundNoise and st->voicedHangover.         *
     *-------------------------------------------------------*/

    st->inBackgroundNoise =
        Bgn_scd(
            &(st->background_state),
            &(st->ltpGainHistory[0]),
            &(synth[0]),
            &(st->voicedHangover),
            pOverflow);

    dtx_dec_activity_update(
        &(st->dtxDecoderState),
        st->lsfState.past_lsf_q,
        synth,
        pOverflow);

    /* store bfi for next subframe */
    st->prev_bf = bfi;
    st->prev_pdf = pdfi;

    /*--------------------------------------------------*
     * Calculate the LSF averages on the eight          *
     * previous frames                                  *
     *--------------------------------------------------*/
    lsp_avg(
        &(st->lsp_avg_st),
        st->lsfState.past_lsf_q,
        pOverflow);

the_end:
    st->dtxDecoderState.dtxGlobalState = newDTXState;

//    return(0);
}