xref: /frameworks/av/media/libstagefright/codecs/amrnb/enc/src/cod_amr.cpp

/* ------------------------------------------------------------------
 * 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/cod_amr.c
 Funtions: cod_amr_init
           cod_amr_reset
           cod_amr_exit
           cod_amr_first
           cod_amr

     Date: 06/09/2000

------------------------------------------------------------------------------
 REVISION HISTORY

 Description: Made changes based on comments from the review meeting.

 Description: Synchronized file with UMTS version 3.2.0. Updated coding
              template. Removed unnecessary include files.

 Description: Added initialization of the overflow flag in cod_amr_init()
              and in cod_amr_reset(). This overflow flag is now part of
              the cod_amrState structure.

 Description: Cleaned up INCLUDES. removed inclusion of basic_op.h and repeat
              inclusion of copy.h

 Description: Updated function call to dtx_enc

 Description:  For cod_amr_first() and cod_amr()
              1. Replaced copy() function with memcpy()

 Description:  Replaced OSCL mem type functions and eliminated include
               files that now are chosen by OSCL definitions

 Description:  Replaced "int" and/or "char" with OSCL defined types.

 Description:

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

 These functions comprise the main encoder routine operating on a frame basis.

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


/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/
#include <stdlib.h>
#include <string.h>

#include "cod_amr.h"
#include "typedef.h"
#include "cnst.h"
#include "copy.h"
#include "qua_gain.h"
#include "lpc.h"
#include "lsp.h"
#include "pre_big.h"
#include "ol_ltp.h"
#include "p_ol_wgh.h"
#include "spreproc.h"
#include "cl_ltp.h"
#include "pred_lt.h"
#include "spstproc.h"
#include "cbsearch.h"
#include "gain_q.h"
#include "convolve.h"
#include "ton_stab.h"
#include "vad.h"
#include "dtx_enc.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
----------------------------------------------------------------------------*/

/* Spectral expansion factors */

static const Word16 gamma1[M] =
{
    30802, 28954, 27217, 25584, 24049,
    22606, 21250, 19975, 18777, 17650
};

/* gamma1 differs for the 12k2 coder */
static const Word16 gamma1_12k2[M] =
{
    29491, 26542, 23888, 21499, 19349,
    17414, 15672, 14105, 12694, 11425
};

static const Word16 gamma2[M] =
{
    19661, 11797, 7078, 4247, 2548,
    1529, 917, 550, 330, 198
};


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

 Inputs:
    state = pointer to a pointer to a structure of type cod_amrState

 Outputs:
    Structure pointed to by the pointer pointed to by state is
      initialized to its reset value
    state points to the allocated memory

 Returns:
    Returns 0 if memory was successfully initialized,
        otherwise returns -1.

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This function allocates memory and initializes state variables.

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

 None.

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

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

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

int cod_amr_init (cod_amrState **state, Flag dtx)
{
  cod_amrState* s;

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

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

  s->lpcSt = NULL;
  s->lspSt = NULL;
  s->clLtpSt = NULL;
  s->gainQuantSt = NULL;
  s->pitchOLWghtSt = NULL;
  s->tonStabSt = NULL;
  s->vadSt = NULL;
  s->dtx_encSt = NULL;
  s->dtx = dtx;

  // Init sub states
  if (cl_ltp_init(&s->clLtpSt) ||
      lsp_init(&s->lspSt) ||
      gainQuant_init(&s->gainQuantSt) ||
      p_ol_wgh_init(&s->pitchOLWghtSt) ||
      ton_stab_init(&s->tonStabSt) ||
#ifndef VAD2
      vad1_init(&s->vadSt) ||
#else
      vad2_init(&s->vadSt) ||
#endif
      dtx_enc_init(&s->dtx_encSt) ||
      lpc_init(&s->lpcSt)) {
     cod_amr_exit(&s);
     return -1;
  }

  cod_amr_reset(s);

  *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 cod_amr_init(cod_amrState **state, Flag dtx)
{
    cod_amrState* s;

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

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

    s->lpcSt = NULL;
    s->lspSt = NULL;
    s->clLtpSt = NULL;
    s->gainQuantSt = NULL;
    s->pitchOLWghtSt = NULL;
    s->tonStabSt = NULL;
    s->vadSt = NULL;
    s->dtx_encSt = NULL;
    s->dtx = dtx;

    /* Initialize overflow Flag */

    s->overflow = 0;


    /* Init sub states */
    if (cl_ltp_init(&s->clLtpSt) ||
            lsp_init(&s->lspSt) ||
            gainQuant_init(&s->gainQuantSt) ||
            p_ol_wgh_init(&s->pitchOLWghtSt) ||
            ton_stab_init(&s->tonStabSt) ||
#ifndef VAD2
            vad1_init(&s->vadSt) ||
#else
            vad2_init(&s->vadSt) ||
#endif
            dtx_enc_init(&s->dtx_encSt) ||
            lpc_init(&s->lpcSt))
    {
        cod_amr_exit(&s);
        return(-1);
    }

    cod_amr_reset(s);

    *state = s;

    return(0);
}

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

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

 Inputs:
    state = pointer to a structure of type cod_amrState

 Outputs:
    Structure pointed to by state is initialized to initial values.

 Returns:
    Returns 0 if memory was successfully initialized,
        otherwise returns -1.

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This function resets the state memory for cod_amr.

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

 None.

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

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

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

int cod_amr_reset (cod_amrState *st)
{
   Word16 i;

   if (st == (cod_amrState *) NULL){
      fprintf(stderr, "cod_amr_reset: invalid parameter\n");
      return -1;
   }

    *-----------------------------------------------------------------------*
    *          Initialize pointers to speech vector.                        *
    *-----------------------------------------------------------------------*

   st->new_speech = st->old_speech + L_TOTAL - L_FRAME;   // New speech

   st->speech = st->new_speech - L_NEXT;                  // Present frame

   st->p_window = st->old_speech + L_TOTAL - L_WINDOW;    // For LPC window
   st->p_window_12k2 = st->p_window - L_NEXT; // EFR LPC window: no lookahead

   // Initialize static pointers

   st->wsp = st->old_wsp + PIT_MAX;
   st->exc = st->old_exc + PIT_MAX + L_INTERPOL;
   st->zero = st->ai_zero + MP1;
   st->error = st->mem_err + M;
   st->h1 = &st->hvec[L_SUBFR];

   // Static vectors to zero

   Set_zero(st->old_speech, L_TOTAL);
   Set_zero(st->old_exc,    PIT_MAX + L_INTERPOL);
   Set_zero(st->old_wsp,    PIT_MAX);
   Set_zero(st->mem_syn,    M);
   Set_zero(st->mem_w,      M);
   Set_zero(st->mem_w0,     M);
   Set_zero(st->mem_err,    M);
   Set_zero(st->zero,       L_SUBFR);
   Set_zero(st->hvec,       L_SUBFR);    // set to zero "h1[-L_SUBFR..-1]"

   // OL LTP states
   for (i = 0; i < 5; i++)
   {
      st->old_lags[i] = 40;
   }

   // Reset lpc states
   lpc_reset(st->lpcSt);

   // Reset lsp states
   lsp_reset(st->lspSt);

   // Reset clLtp states
   cl_ltp_reset(st->clLtpSt);

   gainQuant_reset(st->gainQuantSt);

   p_ol_wgh_reset(st->pitchOLWghtSt);

   ton_stab_reset(st->tonStabSt);

#ifndef VAD2
   vad1_reset(st->vadSt);
#else
   vad2_reset(st->vadSt);
#endif

   dtx_enc_reset(st->dtx_encSt);

   st->sharp = SHARPMIN;

   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 cod_amr_reset(cod_amrState *st)
{
    Word16 i;

    if (st == (cod_amrState *) NULL)
    {
        /* fprint(stderr, "cod_amr_reset: invalid parameter\n");  */
        return(-1);
    }

    /*-----------------------------------------------------------------------*
     *          Initialize pointers to speech vector.                        *
     *-----------------------------------------------------------------------*/

    st->new_speech = st->old_speech + L_TOTAL - L_FRAME;   /* New speech     */

    st->speech = st->new_speech - L_NEXT;                  /* Present frame  */

    st->p_window = st->old_speech + L_TOTAL - L_WINDOW;    /* For LPC window */
    st->p_window_12k2 = st->p_window - L_NEXT; /* EFR LPC window: no lookahead */

    /* Initialize static pointers */

    st->wsp = st->old_wsp + PIT_MAX;
    st->exc = st->old_exc + PIT_MAX + L_INTERPOL;
    st->zero = st->ai_zero + MP1;
    st->error = st->mem_err + M;
    st->h1 = &st->hvec[L_SUBFR];

    /* Initialize overflow Flag */

    st->overflow = 0;

    /* Static vectors to zero */
    memset(st->old_speech, 0, sizeof(Word16)*L_TOTAL);
    memset(st->old_exc, 0,    sizeof(Word16)*(PIT_MAX + L_INTERPOL));
    memset(st->old_wsp, 0,    sizeof(Word16)*PIT_MAX);
    memset(st->mem_syn, 0,    sizeof(Word16)*M);
    memset(st->mem_w,   0,    sizeof(Word16)*M);
    memset(st->mem_w0,  0,    sizeof(Word16)*M);
    memset(st->mem_err, 0,    sizeof(Word16)*M);
    memset(st->zero, 0,       sizeof(Word16)*L_SUBFR);
    memset(st->hvec, 0,       sizeof(Word16)*L_SUBFR);    /* set to zero "h1[-L_SUBFR..-1]" */

    /* OL LTP states */
    for (i = 0; i < 5; i++)
    {
        st->old_lags[i] = 40;
    }

    /* Reset lpc states */
    lpc_reset(st->lpcSt);

    /* Reset lsp states */
    lsp_reset(st->lspSt);

    /* Reset clLtp states */
    cl_ltp_reset(st->clLtpSt);

    gainQuant_reset(st->gainQuantSt);

    p_ol_wgh_reset(st->pitchOLWghtSt);

    ton_stab_reset(st->tonStabSt);

#ifndef VAD2
    vad1_reset(st->vadSt);
#else
    vad2_reset(st->vadSt);
#endif

    dtx_enc_reset(st->dtx_encSt);

    st->sharp = SHARPMIN;

    return(0);
}

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

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

 Inputs:
    state = pointer to a pointer to a structure of type cod_amrState

 Outputs:
    state points to a NULL address

 Returns:
    None.

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This function frees the memory used for state memory.

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

 None.

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

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

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

void cod_amr_exit (cod_amrState **state)
{
   if (state == NULL || *state == NULL)
      return;

   // dealloc members
   lpc_exit(&(*state)->lpcSt);
   lsp_exit(&(*state)->lspSt);
   gainQuant_exit(&(*state)->gainQuantSt);
   cl_ltp_exit(&(*state)->clLtpSt);
   p_ol_wgh_exit(&(*state)->pitchOLWghtSt);
   ton_stab_exit(&(*state)->tonStabSt);
#ifndef VAD2
   vad1_exit(&(*state)->vadSt);
#else
   vad2_exit(&(*state)->vadSt);
#endif
   dtx_enc_exit(&(*state)->dtx_encSt);

   // deallocate memory
   free(*state);
   *state = NULL;

   return;
}

------------------------------------------------------------------------------
 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 cod_amr_exit(cod_amrState **state)
{
    if (state == NULL || *state == NULL)
    {
        return;
    }

    /* dealloc members */
    lpc_exit(&(*state)->lpcSt);
    lsp_exit(&(*state)->lspSt);
    gainQuant_exit(&(*state)->gainQuantSt);
    cl_ltp_exit(&(*state)->clLtpSt);
    p_ol_wgh_exit(&(*state)->pitchOLWghtSt);
    ton_stab_exit(&(*state)->tonStabSt);
#ifndef VAD2
    vad1_exit(&(*state)->vadSt);
#else
    vad2_exit(&(*state)->vadSt);
#endif
    dtx_enc_exit(&(*state)->dtx_encSt);

    /* deallocate memory */
    free(*state); // BX
    *state = NULL;

    return;
}

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

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

 Inputs:
    st = pointer to a structure of type cod_amrState
    new_speech = pointer to buffer of length L_FRAME that contains
                 the speech input (Word16)

 Outputs:
    The structure of type cod_amrState pointed to by st is updated.

 Returns:
    return_value = 0 (int)

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This function copes with look-ahead and calls cod_amr.
 No input argument are passed to this function. However, before
 calling this function, 40 new speech data should be copied to the
 vector new_speech[]. This is a global pointer which is declared in
 this file (it points to the end of speech buffer minus 200).

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

 None.

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

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

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

int cod_amr_first(cod_amrState *st,     // i/o : State struct
                  Word16 new_speech[])  // i   : speech input (L_FRAME)
{
   Copy(new_speech,&st->new_speech[-L_NEXT], L_NEXT);
   //   Copy(new_speech,st->new_speech,L_FRAME);

   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 cod_amr_first(cod_amrState *st,     /* i/o : State struct           */
                     Word16 new_speech[])  /* i   : speech input (L_FRAME) */
{

    memcpy(&st->new_speech[-L_NEXT], new_speech, L_NEXT*sizeof(Word16));

    /*   Copy(new_speech,st->new_speech,L_FRAME); */

    return(0);
}

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

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

 Inputs:
    st = pointer to a structure of type cod_amrState
    mode = AMR mode of type enum Mode
    new_speech = pointer to buffer of length L_FRAME that contains
             the speech input of type Word16
    ana = pointer to the analysis parameters of type Word16
    usedMode = pointer to the used mode of type enum Mode
    synth = pointer to a buffer containing the local synthesis speech of
        type Word16

 Outputs:
    The structure of type cod_amrState pointed to by st is updated.
    The analysis parameter buffer pointed to by ana is updated.
    The value pointed to by usedMode is updated.
    The local synthesis speech buffer pointed to by synth is updated.

 Returns:
    return_value = 0 (int)

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This function is the main encoder routine. It is called every 20 ms speech
 frame, operating on the newly read 160 speech samples. It performs the
 principle encoding functions to produce the set of encoded parameters
 which include the LSP, adaptive codebook, and fixed codebook
 quantization indices (addresses and gains).

 Before calling this function, 160 new speech data should be copied to the
 vector new_speech[]. This is a global pointer which is declared in
 this file (it points to the end of speech buffer minus 160).

 The outputs of the function are:
     ana[]:     vector of analysis parameters.
     synth[]:   Local synthesis speech (for debugging purposes)

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

 None.

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

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

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

int cod_amr(
    cod_amrState *st,          // i/o : State struct
    enum Mode mode,            // i   : AMR mode
    Word16 new_speech[],       // i   : speech input (L_FRAME)
    Word16 ana[],              // o   : Analysis parameters
    enum Mode *usedMode,       // o   : used mode
    Word16 synth[]             // o   : Local synthesis
)
{
   // LPC coefficients
   Word16 A_t[(MP1) * 4];      // A(z) unquantized for the 4 subframes
   Word16 Aq_t[(MP1) * 4];     // A(z)   quantized for the 4 subframes
   Word16 *A, *Aq;             // Pointer on A_t and Aq_t
   Word16 lsp_new[M];

   // Other vectors
   Word16 xn[L_SUBFR];         // Target vector for pitch search
   Word16 xn2[L_SUBFR];        // Target vector for codebook search
   Word16 code[L_SUBFR];       // Fixed codebook excitation
   Word16 y1[L_SUBFR];         // Filtered adaptive excitation
   Word16 y2[L_SUBFR];         // Filtered fixed codebook excitation
   Word16 gCoeff[6];           // Correlations between xn, y1, & y2:
   Word16 res[L_SUBFR];        // Short term (LPC) prediction residual
   Word16 res2[L_SUBFR];       // Long term (LTP) prediction residual

   // Vector and scalars needed for the MR475
   Word16 xn_sf0[L_SUBFR];     // Target vector for pitch search
   Word16 y2_sf0[L_SUBFR];     // Filtered codebook innovation
   Word16 code_sf0[L_SUBFR];   // Fixed codebook excitation
   Word16 h1_sf0[L_SUBFR];     // The impulse response of sf0
   Word16 mem_syn_save[M];     // Filter memory
   Word16 mem_w0_save[M];      // Filter memory
   Word16 mem_err_save[M];     // Filter memory
   Word16 sharp_save;          // Sharpening
   Word16 evenSubfr;           // Even subframe indicator
   Word16 T0_sf0 = 0;          // Integer pitch lag of sf0
   Word16 T0_frac_sf0 = 0;     // Fractional pitch lag of sf0
   Word16 i_subfr_sf0 = 0;     // Position in exc[] for sf0
   Word16 gain_pit_sf0;        // Quantized pitch gain for sf0
   Word16 gain_code_sf0;       // Quantized codebook gain for sf0

   // Scalars
   Word16 i_subfr, subfrNr;
   Word16 T_op[L_FRAME/L_FRAME_BY2];
   Word16 T0, T0_frac;
   Word16 gain_pit, gain_code;

   // Flags
   Word16 lsp_flag = 0;        // indicates resonance in LPC filter
   Word16 gp_limit;            // pitch gain limit value
   Word16 vad_flag;            // VAD decision flag
   Word16 compute_sid_flag;    // SID analysis  flag

   Copy(new_speech, st->new_speech, L_FRAME);

   *usedMode = mode;

   // DTX processing
   if (st->dtx)
   {  // no test() call since this if is only in simulation env
      // Find VAD decision

#ifdef  VAD2
      vad_flag = vad2 (st->new_speech,    st->vadSt);
      vad_flag = vad2 (st->new_speech+80, st->vadSt) || vad_flag;
#else
      vad_flag = vad1(st->vadSt, st->new_speech);
#endif

      // NB! usedMode may change here
      compute_sid_flag = tx_dtx_handler(st->dtx_encSt,
                                        vad_flag,
                                        usedMode);
   }
   else
   {
      compute_sid_flag = 0;
   }

    *------------------------------------------------------------------------*
    *  - Perform LPC analysis:                                               *
    *       * autocorrelation + lag windowing                                *
    *       * Levinson-durbin algorithm to find a[]                          *
    *       * convert a[] to lsp[]                                           *
    *       * quantize and code the LSPs                                     *
    *       * find the interpolated LSPs and convert to a[] for all          *
    *         subframes (both quantized and unquantized)                     *
    *------------------------------------------------------------------------*

   // LP analysis
   lpc(st->lpcSt, mode, st->p_window, st->p_window_12k2, A_t);


   // From A(z) to lsp. LSP quantization and interpolation
   lsp(st->lspSt, mode, *usedMode, A_t, Aq_t, lsp_new, &ana);


   // Buffer lsp's and energy
   dtx_buffer(st->dtx_encSt,
          lsp_new,
          st->new_speech);

   // Check if in DTX mode
   if (sub(*usedMode, MRDTX) == 0)
   {
      dtx_enc(st->dtx_encSt,
              compute_sid_flag,
              st->lspSt->qSt,
              st->gainQuantSt->gc_predSt,
              &ana);

      Set_zero(st->old_exc,    PIT_MAX + L_INTERPOL);
      Set_zero(st->mem_w0,     M);
      Set_zero(st->mem_err,    M);
      Set_zero(st->zero,       L_SUBFR);
      Set_zero(st->hvec,       L_SUBFR);    // set to zero "h1[-L_SUBFR..-1]"
      // Reset lsp states
      lsp_reset(st->lspSt);
      Copy(lsp_new, st->lspSt->lsp_old, M);
      Copy(lsp_new, st->lspSt->lsp_old_q, M);

      // Reset clLtp states
      cl_ltp_reset(st->clLtpSt);
      st->sharp = SHARPMIN;
   }
   else
   {
       // check resonance in the filter
      lsp_flag = check_lsp(st->tonStabSt, st->lspSt->lsp_old);
   }

    *----------------------------------------------------------------------*
    * - Find the weighted input speech w_sp[] for the whole speech frame   *
    * - Find the open-loop pitch delay for first 2 subframes               *
    * - Set the range for searching closed-loop pitch in 1st subframe      *
    * - Find the open-loop pitch delay for last 2 subframes                *
    *----------------------------------------------------------------------*

#ifdef VAD2
   if (st->dtx)
   {  // no test() call since this if is only in simulation env
       st->vadSt->L_Rmax = 0;
       st->vadSt->L_R0 = 0;
   }
#endif
   for(subfrNr = 0, i_subfr = 0;
       subfrNr < L_FRAME/L_FRAME_BY2;
       subfrNr++, i_subfr += L_FRAME_BY2)
   {
      // Pre-processing on 80 samples
      pre_big(mode, gamma1, gamma1_12k2, gamma2, A_t, i_subfr, st->speech,
              st->mem_w, st->wsp);

      if ((sub(mode, MR475) != 0) && (sub(mode, MR515) != 0))
      {
         // Find open loop pitch lag for two subframes
         ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[i_subfr],
                &T_op[subfrNr], st->old_lags, st->ol_gain_flg, subfrNr,
                st->dtx);
      }
   }

   if ((sub(mode, MR475) == 0) || (sub(mode, MR515) == 0))
   {
      // Find open loop pitch lag for ONE FRAME ONLY
      // search on 160 samples

      ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[0], &T_op[0],
             st->old_lags, st->ol_gain_flg, 1, st->dtx);
      T_op[1] = T_op[0];
   }

#ifdef VAD2
   if (st->dtx)
   {  // no test() call since this if is only in simulation env
      LTP_flag_update(st->vadSt, mode);
   }
#endif

#ifndef VAD2
   // run VAD pitch detection
   if (st->dtx)
   {  // no test() call since this if is only in simulation env
      vad_pitch_detection(st->vadSt, T_op);
   }
#endif

   if (sub(*usedMode, MRDTX) == 0)
   {
      goto the_end;
   }

    *------------------------------------------------------------------------*
    *          Loop for every subframe in the analysis frame                 *
    *------------------------------------------------------------------------*
    *  To find the pitch and innovation parameters. The subframe size is     *
    *  L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times.               *
    *     - find the weighted LPC coefficients                               *
    *     - find the LPC residual signal res[]                               *
    *     - compute the target signal for pitch search                       *
    *     - compute impulse response of weighted synthesis filter (h1[])     *
    *     - find the closed-loop pitch parameters                            *
    *     - encode the pitch dealy                                           *
    *     - update the impulse response h1[] by including fixed-gain pitch   *
    *     - find target vector for codebook search                           *
    *     - codebook search                                                  *
    *     - encode codebook address                                          *
    *     - VQ of pitch and codebook gains                                   *
    *     - find synthesis speech                                            *
    *     - update states of weighting filter                                *
    *------------------------------------------------------------------------*

   A = A_t;      // pointer to interpolated LPC parameters
   Aq = Aq_t;    // pointer to interpolated quantized LPC parameters

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

      // Save states for the MR475 mode
      if ((evenSubfr != 0) && (sub(*usedMode, MR475) == 0))
      {
         Copy(st->mem_syn, mem_syn_save, M);
         Copy(st->mem_w0, mem_w0_save, M);
         Copy(st->mem_err, mem_err_save, M);
         sharp_save = st->sharp;
      }

       *-----------------------------------------------------------------*
       * - Preprocessing of subframe                                     *
       *-----------------------------------------------------------------*
      if (sub(*usedMode, MR475) != 0)
      {
         subframePreProc(*usedMode, gamma1, gamma1_12k2,
                         gamma2, A, Aq, &st->speech[i_subfr],
                         st->mem_err, st->mem_w0, st->zero,
                         st->ai_zero, &st->exc[i_subfr],
                         st->h1, xn, res, st->error);
      }
      else
      { // MR475
         subframePreProc(*usedMode, gamma1, gamma1_12k2,
                         gamma2, A, Aq, &st->speech[i_subfr],
                         st->mem_err, mem_w0_save, st->zero,
                         st->ai_zero, &st->exc[i_subfr],
                         st->h1, xn, res, st->error);

         // save impulse response (modified in cbsearch)
         if (evenSubfr != 0)
         {
             Copy (st->h1, h1_sf0, L_SUBFR);
         }
      }

      // copy the LP residual (res2 is modified in the CL LTP search)
      Copy (res, res2, L_SUBFR);


       *-----------------------------------------------------------------*
       * - Closed-loop LTP search                                        *
       *-----------------------------------------------------------------*
      cl_ltp(st->clLtpSt, st->tonStabSt, *usedMode, i_subfr, T_op, st->h1,
             &st->exc[i_subfr], res2, xn, lsp_flag, xn2, y1,
             &T0, &T0_frac, &gain_pit, gCoeff, &ana,
             &gp_limit);

      // update LTP lag history
      if ((subfrNr == 0) && (st->ol_gain_flg[0] > 0))
      {
         st->old_lags[1] = T0;
      }

      if ((sub(subfrNr, 3) == 0) && (st->ol_gain_flg[1] > 0))
      {
         st->old_lags[0] = T0;
      }


       *-----------------------------------------------------------------*
       * - Inovative codebook search (find index and gain)               *
       *-----------------------------------------------------------------*
      cbsearch(xn2, st->h1, T0, st->sharp, gain_pit, res2,
               code, y2, &ana, *usedMode, subfrNr);

       *------------------------------------------------------*
       * - Quantization of gains.                             *
       *------------------------------------------------------*
      gainQuant(st->gainQuantSt, *usedMode, res, &st->exc[i_subfr], code,
                xn, xn2,  y1, y2, gCoeff, evenSubfr, gp_limit,
                &gain_pit_sf0, &gain_code_sf0,
                &gain_pit, &gain_code, &ana);

      // update gain history
      update_gp_clipping(st->tonStabSt, gain_pit);

      if (sub(*usedMode, MR475) != 0)
      {
         // Subframe Post Porcessing
         subframePostProc(st->speech, *usedMode, i_subfr, gain_pit,
                          gain_code, Aq, synth, xn, code, y1, y2, st->mem_syn,
                          st->mem_err, st->mem_w0, st->exc, &st->sharp);
      }
      else
      {
         if (evenSubfr != 0)
         {
            i_subfr_sf0 = i_subfr;
            Copy(xn, xn_sf0, L_SUBFR);
            Copy(y2, y2_sf0, L_SUBFR);
            Copy(code, code_sf0, L_SUBFR);
            T0_sf0 = T0;
            T0_frac_sf0 = T0_frac;

            // Subframe Post Porcessing
            subframePostProc(st->speech, *usedMode, i_subfr, gain_pit,
                             gain_code, Aq, synth, xn, code, y1, y2,
                             mem_syn_save, st->mem_err, mem_w0_save,
                             st->exc, &st->sharp);
            st->sharp = sharp_save;
         }
         else
         {
            // update both subframes for the MR475

            // Restore states for the MR475 mode
            Copy(mem_err_save, st->mem_err, M);

            // re-build excitation for sf 0
            Pred_lt_3or6(&st->exc[i_subfr_sf0], T0_sf0, T0_frac_sf0,
                         L_SUBFR, 1);
            Convolve(&st->exc[i_subfr_sf0], h1_sf0, y1, L_SUBFR);

            Aq -= MP1;
            subframePostProc(st->speech, *usedMode, i_subfr_sf0,
                             gain_pit_sf0, gain_code_sf0, Aq,
                             synth, xn_sf0, code_sf0, y1, y2_sf0,
                             st->mem_syn, st->mem_err, st->mem_w0, st->exc,
                             &sharp_save); // overwrites sharp_save
            Aq += MP1;

            // re-run pre-processing to get xn right (needed by postproc)
            // (this also reconstructs the unsharpened h1 for sf 1)
            subframePreProc(*usedMode, gamma1, gamma1_12k2,
                            gamma2, A, Aq, &st->speech[i_subfr],
                            st->mem_err, st->mem_w0, st->zero,
                            st->ai_zero, &st->exc[i_subfr],
                            st->h1, xn, res, st->error);

            // re-build excitation sf 1 (changed if lag < L_SUBFR)
            Pred_lt_3or6(&st->exc[i_subfr], T0, T0_frac, L_SUBFR, 1);
            Convolve(&st->exc[i_subfr], st->h1, y1, L_SUBFR);

            subframePostProc(st->speech, *usedMode, i_subfr, gain_pit,
                             gain_code, Aq, synth, xn, code, y1, y2,
                             st->mem_syn, st->mem_err, st->mem_w0,
                             st->exc, &st->sharp);
         }
      }


      A += MP1;    // interpolated LPC parameters for next subframe
      Aq += MP1;
   }

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

the_end:

    *--------------------------------------------------*
    * Update signal for next frame.                    *
    *--------------------------------------------------*
   Copy(&st->old_wsp[L_FRAME], &st->old_wsp[0], PIT_MAX);

   Copy(&st->old_speech[L_FRAME], &st->old_speech[0], L_TOTAL - L_FRAME);

   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 cod_amr(
    cod_amrState *st,          /* i/o : State struct                   */
    enum Mode mode,            /* i   : AMR mode                       */
    Word16 new_speech[],       /* i   : speech input (L_FRAME)         */
    Word16 ana[],              /* o   : Analysis parameters            */
    enum Mode *usedMode,       /* o   : used mode                      */
    Word16 synth[]            /* o   : Local synthesis                */
)
{
    /* LPC coefficients */
    Word16 A_t[(MP1) * 4];      /* A(z) unquantized for the 4 subframes */
    Word16 Aq_t[(MP1) * 4];     /* A(z)   quantized for the 4 subframes */
    Word16 *A, *Aq;             /* Pointer on A_t and Aq_t              */
    Word16 lsp_new[M];

    /* Other vectors */
    Word16 xn[L_SUBFR];         /* Target vector for pitch search       */
    Word16 xn2[L_SUBFR];        /* Target vector for codebook search    */
    Word16 code[L_SUBFR];       /* Fixed codebook excitation            */
    Word16 y1[L_SUBFR];         /* Filtered adaptive excitation         */
    Word16 y2[L_SUBFR];         /* Filtered fixed codebook excitation   */
    Word16 gCoeff[6];           /* Correlations between xn, y1, & y2:   */
    Word16 res[L_SUBFR];        /* Short term (LPC) prediction residual */
    Word16 res2[L_SUBFR];       /* Long term (LTP) prediction residual  */

    /* Vector and scalars needed for the MR475 */
    Word16 xn_sf0[L_SUBFR];     /* Target vector for pitch search       */
    Word16 y2_sf0[L_SUBFR];     /* Filtered codebook innovation         */
    Word16 code_sf0[L_SUBFR];   /* Fixed codebook excitation            */
    Word16 h1_sf0[L_SUBFR];     /* The impulse response of sf0          */
    Word16 mem_syn_save[M];     /* Filter memory                        */
    Word16 mem_w0_save[M];      /* Filter memory                        */
    Word16 mem_err_save[M];     /* Filter memory                        */
    Word16 sharp_save;          /* Sharpening                           */
    Word16 evenSubfr;           /* Even subframe indicator              */
    Word16 T0_sf0 = 0;          /* Integer pitch lag of sf0             */
    Word16 T0_frac_sf0 = 0;     /* Fractional pitch lag of sf0          */
    Word16 i_subfr_sf0 = 0;     /* Position in exc[] for sf0            */
    Word16 gain_pit_sf0;        /* Quantized pitch gain for sf0         */
    Word16 gain_code_sf0;       /* Quantized codebook gain for sf0      */

    /* Scalars */
    Word16 i_subfr, subfrNr;
    Word16 T_op[L_FRAME/L_FRAME_BY2];
    Word16 T0, T0_frac;
    Word16 gain_pit, gain_code;

    /* Flags */
    Word16 lsp_flag = 0;        /* indicates resonance in LPC filter    */
    Word16 gp_limit;            /* pitch gain limit value               */
    Word16 vad_flag;            /* VAD decision flag                    */
    Word16 compute_sid_flag;    /* SID analysis  flag                   */
    Flag   *pOverflow = &(st->overflow);     /* Overflow flag            */


    memcpy(st->new_speech, new_speech, L_FRAME*sizeof(Word16));

    *usedMode = mode;

    /* DTX processing */
    if (st->dtx)
    {
        /* Find VAD decision */
#ifdef  VAD2
        vad_flag = vad2(st->new_speech,    st->vadSt, pOverflow);
        vad_flag = vad2(st->new_speech + 80, st->vadSt, pOverflow) || vad_flag;
#else
        vad_flag = vad1(st->vadSt, st->new_speech, pOverflow);
#endif

        /* NB! usedMode may change here */
        compute_sid_flag = tx_dtx_handler(st->dtx_encSt,
                                          vad_flag,
                                          usedMode, pOverflow);
    }
    else
    {
        compute_sid_flag = 0;
    }

    /*------------------------------------------------------------------------*
    *  - Perform LPC analysis:                                               *
    *       * autocorrelation + lag windowing                                *
    *       * Levinson-durbin algorithm to find a[]                          *
    *       * convert a[] to lsp[]                                           *
    *       * quantize and code the LSPs                                     *
    *       * find the interpolated LSPs and convert to a[] for all          *
    *         subframes (both quantized and unquantized)                     *
    *------------------------------------------------------------------------*/

    /* LP analysis */
    lpc(st->lpcSt, mode, st->p_window, st->p_window_12k2, A_t, pOverflow);

    /* From A(z) to lsp. LSP quantization and interpolation */
    lsp(st->lspSt, mode, *usedMode, A_t, Aq_t, lsp_new, &ana, pOverflow);

    /* Buffer lsp's and energy */
    dtx_buffer(st->dtx_encSt,
               lsp_new,
               st->new_speech, pOverflow);

    /* Check if in DTX mode */

    if (*usedMode == MRDTX)
    {
        dtx_enc(st->dtx_encSt,
                compute_sid_flag,
                st->lspSt->qSt,
                &(st->gainQuantSt->gc_predSt),
                &ana, pOverflow);

        memset(st->old_exc, 0,   sizeof(Word16)*(PIT_MAX + L_INTERPOL));
        memset(st->mem_w0,  0,   sizeof(Word16)*M);
        memset(st->mem_err, 0,   sizeof(Word16)*M);
        memset(st->zero,    0,   sizeof(Word16)*L_SUBFR);
        memset(st->hvec,    0,   sizeof(Word16)*L_SUBFR);    /* set to zero "h1[-L_SUBFR..-1]" */
        /* Reset lsp states */
        lsp_reset(st->lspSt);

        memcpy(st->lspSt->lsp_old,   lsp_new, M*sizeof(Word16));
        memcpy(st->lspSt->lsp_old_q, lsp_new, M*sizeof(Word16));

        /* Reset clLtp states */
        cl_ltp_reset(st->clLtpSt);
        st->sharp = SHARPMIN;
    }
    else
    {
        /* check resonance in the filter */
        lsp_flag = check_lsp(st->tonStabSt, st->lspSt->lsp_old, pOverflow);
    }

    /*----------------------------------------------------------------------*
    * - Find the weighted input speech w_sp[] for the whole speech frame   *
    * - Find the open-loop pitch delay for first 2 subframes               *
    * - Set the range for searching closed-loop pitch in 1st subframe      *
    * - Find the open-loop pitch delay for last 2 subframes                *
    *----------------------------------------------------------------------*/

#ifdef VAD2
    if (st->dtx)
    {
        st->vadSt->L_Rmax = 0;
        st->vadSt->L_R0 = 0;
    }
#endif

    for (subfrNr = 0, i_subfr = 0;
            subfrNr < L_FRAME / L_FRAME_BY2;
            subfrNr++, i_subfr += L_FRAME_BY2)
    {
        /* Pre-processing on 80 samples */
        pre_big(mode, gamma1, gamma1_12k2, gamma2, A_t, i_subfr, st->speech,
                st->mem_w, st->wsp, pOverflow);


        if ((mode != MR475) && (mode != MR515))
        {
            /* Find open loop pitch lag for two subframes */
            ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[i_subfr],
                   &T_op[subfrNr], st->old_lags, st->ol_gain_flg, subfrNr,
                   st->dtx, pOverflow);
        }
    }

    if ((mode == MR475) || (mode == MR515))
    {
        /* Find open loop pitch lag for ONE FRAME ONLY */
        /* search on 160 samples */

        ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[0], &T_op[0],
               st->old_lags, st->ol_gain_flg, 1, st->dtx, pOverflow);
        T_op[1] = T_op[0];
    }

#ifdef VAD2
    if (st->dtx)
    {
        LTP_flag_update(st->vadSt, (Word16) mode, pOverflow);
    }
#endif

#ifndef VAD2
    /* run VAD pitch detection */
    if (st->dtx)
    {
        vad_pitch_detection(st->vadSt, T_op, pOverflow);
    }
#endif

    if (*usedMode == MRDTX)
    {
        goto the_end;
    }

    /*------------------------------------------------------------------------*
    *          Loop for every subframe in the analysis frame                 *
    *------------------------------------------------------------------------*
    *  To find the pitch and innovation parameters. The subframe size is     *
    *  L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times.               *
    *     - find the weighted LPC coefficients                               *
    *     - find the LPC residual signal res[]                               *
    *     - compute the target signal for pitch search                       *
    *     - compute impulse response of weighted synthesis filter (h1[])     *
    *     - find the closed-loop pitch parameters                            *
    *     - encode the pitch dealy                                           *
    *     - update the impulse response h1[] by including fixed-gain pitch   *
    *     - find target vector for codebook search                           *
    *     - codebook search                                                  *
    *     - encode codebook address                                          *
    *     - VQ of pitch and codebook gains                                   *
    *     - find synthesis speech                                            *
    *     - update states of weighting filter                                *
    *------------------------------------------------------------------------*/

    A = A_t;      /* pointer to interpolated LPC parameters */
    Aq = Aq_t;    /* pointer to interpolated quantized LPC parameters */

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

        /* Save states for the MR475 mode */

        if ((evenSubfr != 0) && (*usedMode == MR475))
        {
            memcpy(mem_syn_save, st->mem_syn, M*sizeof(Word16));
            memcpy(mem_w0_save, st->mem_w0, M*sizeof(Word16));
            memcpy(mem_err_save, st->mem_err, M*sizeof(Word16));

            sharp_save = st->sharp;
        }

        /*-----------------------------------------------------------------*
        * - Preprocessing of subframe                                     *
        *-----------------------------------------------------------------*/

        if (*usedMode != MR475)
        {
            subframePreProc(*usedMode, gamma1, gamma1_12k2,
                            gamma2, A, Aq, &st->speech[i_subfr],
                            st->mem_err, st->mem_w0, st->zero,
                            st->ai_zero, &st->exc[i_subfr],
                            st->h1, xn, res, st->error);
        }
        else
        { /* MR475 */
            subframePreProc(*usedMode, gamma1, gamma1_12k2,
                            gamma2, A, Aq, &st->speech[i_subfr],
                            st->mem_err, mem_w0_save, st->zero,
                            st->ai_zero, &st->exc[i_subfr],
                            st->h1, xn, res, st->error);

            /* save impulse response (modified in cbsearch) */

            if (evenSubfr != 0)
            {
                memcpy(h1_sf0, st->h1, L_SUBFR*sizeof(Word16));

            }
        }

        /* copy the LP residual (res2 is modified in the CL LTP search)    */
        memcpy(res2, res, L_SUBFR*sizeof(Word16));

        /*-----------------------------------------------------------------*
        * - Closed-loop LTP search                                        *
        *-----------------------------------------------------------------*/
        cl_ltp(st->clLtpSt, st->tonStabSt, *usedMode, i_subfr, T_op, st->h1,
               &st->exc[i_subfr], res2, xn, lsp_flag, xn2, y1,
               &T0, &T0_frac, &gain_pit, gCoeff, &ana,
               &gp_limit, pOverflow);

        /* update LTP lag history */

        if ((subfrNr == 0) && (st->ol_gain_flg[0] > 0))
        {
            st->old_lags[1] = T0;
        }


        if ((subfrNr == 3) && (st->ol_gain_flg[1] > 0))
        {
            st->old_lags[0] = T0;
        }

        /*-----------------------------------------------------------------*
        * - Inovative codebook search (find index and gain)               *
        *-----------------------------------------------------------------*/
        cbsearch(xn2, st->h1, T0, st->sharp, gain_pit, res2,
                 code, y2, &ana, *usedMode, subfrNr, pOverflow);

        /*------------------------------------------------------*
        * - Quantization of gains.                             *
        *------------------------------------------------------*/
        gainQuant(st->gainQuantSt, *usedMode, res, &st->exc[i_subfr], code,
                  xn, xn2,  y1, y2, gCoeff, evenSubfr, gp_limit,
                  &gain_pit_sf0, &gain_code_sf0,
                  &gain_pit, &gain_code, &ana, pOverflow);

        /* update gain history */
        update_gp_clipping(st->tonStabSt, gain_pit, pOverflow);


        if (*usedMode != MR475)
        {
            /* Subframe Post Porcessing */
            subframePostProc(st->speech, *usedMode, i_subfr, gain_pit,
                             gain_code, Aq, synth, xn, code, y1, y2, st->mem_syn,
                             st->mem_err, st->mem_w0, st->exc, &st->sharp, pOverflow);
        }
        else
        {

            if (evenSubfr != 0)
            {
                i_subfr_sf0 = i_subfr;

                memcpy(xn_sf0, xn, L_SUBFR*sizeof(Word16));
                memcpy(y2_sf0, y2, L_SUBFR*sizeof(Word16));
                memcpy(code_sf0, code, L_SUBFR*sizeof(Word16));

                T0_sf0 = T0;
                T0_frac_sf0 = T0_frac;

                /* Subframe Post Porcessing */
                subframePostProc(st->speech, *usedMode, i_subfr, gain_pit,
                                 gain_code, Aq, synth, xn, code, y1, y2,
                                 mem_syn_save, st->mem_err, mem_w0_save,
                                 st->exc, &st->sharp, pOverflow);
                st->sharp = sharp_save;
            }
            else
            {
                /* update both subframes for the MR475 */

                /* Restore states for the MR475 mode */
                memcpy(st->mem_err, mem_err_save, M*sizeof(Word16));


                /* re-build excitation for sf 0 */
                Pred_lt_3or6(&st->exc[i_subfr_sf0], T0_sf0, T0_frac_sf0,
                             L_SUBFR, 1, pOverflow);
                Convolve(&st->exc[i_subfr_sf0], h1_sf0, y1, L_SUBFR);

                Aq -= MP1;
                subframePostProc(st->speech, *usedMode, i_subfr_sf0,
                                 gain_pit_sf0, gain_code_sf0, Aq,
                                 synth, xn_sf0, code_sf0, y1, y2_sf0,
                                 st->mem_syn, st->mem_err, st->mem_w0, st->exc,
                                 &sharp_save, pOverflow); /* overwrites sharp_save */
                Aq += MP1;

                /* re-run pre-processing to get xn right (needed by postproc) */
                /* (this also reconstructs the unsharpened h1 for sf 1)       */
                subframePreProc(*usedMode, gamma1, gamma1_12k2,
                                gamma2, A, Aq, &st->speech[i_subfr],
                                st->mem_err, st->mem_w0, st->zero,
                                st->ai_zero, &st->exc[i_subfr],
                                st->h1, xn, res, st->error);

                /* re-build excitation sf 1 (changed if lag < L_SUBFR) */
                Pred_lt_3or6(&st->exc[i_subfr], T0, T0_frac, L_SUBFR, 1, pOverflow);
                Convolve(&st->exc[i_subfr], st->h1, y1, L_SUBFR);

                subframePostProc(st->speech, *usedMode, i_subfr, gain_pit,
                                 gain_code, Aq, synth, xn, code, y1, y2,
                                 st->mem_syn, st->mem_err, st->mem_w0,
                                 st->exc, &st->sharp, pOverflow);
            }
        }

        A += MP1;    /* interpolated LPC parameters for next subframe */
        Aq += MP1;
    }

    memcpy(&st->old_exc[0], &st->old_exc[L_FRAME], (PIT_MAX + L_INTERPOL)*sizeof(Word16));

the_end:

    /*--------------------------------------------------*
    * Update signal for next frame.                    *
    *--------------------------------------------------*/

    memcpy(&st->old_wsp[0], &st->old_wsp[L_FRAME], PIT_MAX*sizeof(Word16));
    memcpy(&st->old_speech[0], &st->old_speech[L_FRAME], (L_TOTAL - L_FRAME)*sizeof(Word16));

    return(0);
}