xref: /frameworks/av/media/libstagefright/codecs/amrwbenc/src/voAMRWBEnc.c

/*
 ** Copyright 2003-2010, VisualOn, Inc.
 **
 ** 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.
 */

/***********************************************************************
*      File: voAMRWBEnc.c                                              *
*                                                                      *
*      Description: Performs the main encoder routine                  *
*                   Fixed-point C simulation of AMR WB ACELP coding    *
*           algorithm with 20 msspeech frames for              *
*           wideband speech signals.                           *
*                                                                      *
************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "typedef.h"
#include "basic_op.h"
#include "oper_32b.h"
#include "math_op.h"
#include "cnst.h"
#include "acelp.h"
#include "cod_main.h"
#include "bits.h"
#include "main.h"
#include "voAMRWB.h"
#include "mem_align.h"
#include "cmnMemory.h"

#define UNUSED(x) (void)(x)

#ifdef __cplusplus
extern "C" {
#endif

/* LPC interpolation coef {0.45, 0.8, 0.96, 1.0}; in Q15 */
static Word16 interpol_frac[NB_SUBFR] = {14746, 26214, 31457, 32767};

/* isp tables for initialization */
static Word16 isp_init[M] =
{
    32138, 30274, 27246, 23170, 18205, 12540, 6393, 0,
    -6393, -12540, -18205, -23170, -27246, -30274, -32138, 1475
};

static Word16 isf_init[M] =
{
    1024, 2048, 3072, 4096, 5120, 6144, 7168, 8192,
    9216, 10240, 11264, 12288, 13312, 14336, 15360, 3840
};

/* High Band encoding */
static const Word16 HP_gain[16] =
{
    3624, 4673, 5597, 6479, 7425, 8378, 9324, 10264,
    11210, 12206, 13391, 14844, 16770, 19655, 24289, 32728
};

/* Private function declaration */
static Word16 synthesis(
            Word16 Aq[],                          /* A(z)  : quantized Az               */
            Word16 exc[],                         /* (i)   : excitation at 12kHz        */
            Word16 Q_new,                         /* (i)   : scaling performed on exc   */
            Word16 synth16k[],                    /* (o)   : 16kHz synthesis signal     */
            Coder_State * st                      /* (i/o) : State structure            */
            );

/* Codec some parameters initialization */
void Reset_encoder(void *st, Word16 reset_all)
{
    Word16 i;
    Coder_State *cod_state;
    cod_state = (Coder_State *) st;
    Set_zero(cod_state->old_exc, PIT_MAX + L_INTERPOL);
    Set_zero(cod_state->mem_syn, M);
    Set_zero(cod_state->past_isfq, M);
    cod_state->mem_w0 = 0;
    cod_state->tilt_code = 0;
    cod_state->first_frame = 1;
    Init_gp_clip(cod_state->gp_clip);
    cod_state->L_gc_thres = 0;
    if (reset_all != 0)
    {
        /* Static vectors to zero */
        Set_zero(cod_state->old_speech, L_TOTAL - L_FRAME);
        Set_zero(cod_state->old_wsp, (PIT_MAX / OPL_DECIM));
        Set_zero(cod_state->mem_decim2, 3);
        /* routines initialization */
        Init_Decim_12k8(cod_state->mem_decim);
        Init_HP50_12k8(cod_state->mem_sig_in);
        Init_Levinson(cod_state->mem_levinson);
        Init_Q_gain2(cod_state->qua_gain);
        Init_Hp_wsp(cod_state->hp_wsp_mem);
        /* isp initialization */
        Copy(isp_init, cod_state->ispold, M);
        Copy(isp_init, cod_state->ispold_q, M);
        /* variable initialization */
        cod_state->mem_preemph = 0;
        cod_state->mem_wsp = 0;
        cod_state->Q_old = 15;
        cod_state->Q_max[0] = 15;
        cod_state->Q_max[1] = 15;
        cod_state->old_wsp_max = 0;
        cod_state->old_wsp_shift = 0;
        /* pitch ol initialization */
        cod_state->old_T0_med = 40;
        cod_state->ol_gain = 0;
        cod_state->ada_w = 0;
        cod_state->ol_wght_flg = 0;
        for (i = 0; i < 5; i++)
        {
            cod_state->old_ol_lag[i] = 40;
        }
        Set_zero(cod_state->old_hp_wsp, (L_FRAME / 2) / OPL_DECIM + (PIT_MAX / OPL_DECIM));
        Set_zero(cod_state->mem_syn_hf, M);
        Set_zero(cod_state->mem_syn_hi, M);
        Set_zero(cod_state->mem_syn_lo, M);
        Init_HP50_12k8(cod_state->mem_sig_out);
        Init_Filt_6k_7k(cod_state->mem_hf);
        Init_HP400_12k8(cod_state->mem_hp400);
        Copy(isf_init, cod_state->isfold, M);
        cod_state->mem_deemph = 0;
        cod_state->seed2 = 21845;
        Init_Filt_6k_7k(cod_state->mem_hf2);
        cod_state->gain_alpha = 32767;
        cod_state->vad_hist = 0;
        wb_vad_reset(cod_state->vadSt);
        dtx_enc_reset(cod_state->dtx_encSt, isf_init);
    }
    return;
}

/*-----------------------------------------------------------------*
*   Funtion  coder                                                *
*            ~~~~~                                                *
*   ->Main coder routine.                                         *
*                                                                 *
*-----------------------------------------------------------------*/
void coder(
        Word16 * mode,                        /* input :  used mode                             */
        Word16 speech16k[],                   /* input :  320 new speech samples (at 16 kHz)    */
        Word16 prms[],                        /* output:  output parameters                     */
        Word16 * ser_size,                    /* output:  bit rate of the used mode             */
        void *spe_state,                      /* i/o   :  State structure                       */
        Word16 allow_dtx                      /* input :  DTX ON/OFF                            */
      )
{
    /* Coder states */
    Coder_State *st;
    /* Speech vector */
    Word16 old_speech[L_TOTAL];
    Word16 *new_speech, *speech, *p_window;

    /* Weighted speech vector */
    Word16 old_wsp[L_FRAME + (PIT_MAX / OPL_DECIM)];
    Word16 *wsp;

    /* Excitation vector */
    Word16 old_exc[(L_FRAME + 1) + PIT_MAX + L_INTERPOL];
    Word16 *exc;

    /* LPC coefficients */
    Word16 r_h[M + 1], r_l[M + 1];         /* Autocorrelations of windowed speech  */
    Word16 rc[M];                          /* Reflection coefficients.             */
    Word16 Ap[M + 1];                      /* A(z) with spectral expansion         */
    Word16 ispnew[M];                      /* immittance spectral pairs at 4nd sfr */
    Word16 ispnew_q[M];                    /* quantized ISPs at 4nd subframe       */
    Word16 isf[M];                         /* ISF (frequency domain) at 4nd sfr    */
    Word16 *p_A, *p_Aq;                    /* ptr to A(z) for the 4 subframes      */
    Word16 A[NB_SUBFR * (M + 1)];          /* A(z) unquantized for the 4 subframes */
    Word16 Aq[NB_SUBFR * (M + 1)];         /* A(z)   quantized for the 4 subframes */

    /* Other vectors */
    Word16 xn[L_SUBFR];                    /* Target vector for pitch search     */
    Word16 xn2[L_SUBFR];                   /* Target vector for codebook search  */
    Word16 dn[L_SUBFR];                    /* Correlation between xn2 and h1     */
    Word16 cn[L_SUBFR];                    /* Target vector in residual domain   */
    Word16 h1[L_SUBFR];                    /* Impulse response vector            */
    Word16 h2[L_SUBFR];                    /* Impulse response vector            */
    Word16 code[L_SUBFR];                  /* Fixed codebook excitation          */
    Word16 y1[L_SUBFR];                    /* Filtered adaptive excitation       */
    Word16 y2[L_SUBFR];                    /* Filtered adaptive excitation       */
    Word16 error[M + L_SUBFR];             /* error of quantization              */
    Word16 synth[L_SUBFR];                 /* 12.8kHz synthesis vector           */
    Word16 exc2[L_FRAME];                  /* excitation vector                  */
    Word16 buf[L_FRAME];                   /* VAD buffer                         */

    /* Scalars */
    Word32 i, j, i_subfr, select, pit_flag, clip_gain, vad_flag;
    Word16 codec_mode;
    Word16 T_op, T_op2, T0, T0_min, T0_max, T0_frac, index;
    Word16 gain_pit, gain_code, g_coeff[4], g_coeff2[4];
    Word16 tmp, gain1, gain2, exp, Q_new, mu, shift, max;
    Word16 voice_fac;
    Word16 indice[8];
    Word32 L_tmp, L_gain_code, L_max, L_tmp1;
    Word16 code2[L_SUBFR];                         /* Fixed codebook excitation  */
    Word16 stab_fac, fac, gain_code_lo;

    Word16 corr_gain;
    Word16 *vo_p0, *vo_p1, *vo_p2, *vo_p3;

    st = (Coder_State *) spe_state;

    *ser_size = nb_of_bits[*mode];
    codec_mode = *mode;

    /*--------------------------------------------------------------------------*
     *          Initialize pointers to speech vector.                           *
     *                                                                          *
     *                                                                          *
     *                    |-------|-------|-------|-------|-------|-------|     *
     *                     past sp   sf1     sf2     sf3     sf4    L_NEXT      *
     *                    <-------  Total speech buffer (L_TOTAL)   ------>     *
     *              old_speech                                                  *
     *                    <-------  LPC analysis window (L_WINDOW)  ------>     *
     *                    |       <-- present frame (L_FRAME) ---->             *
     *                   p_window |       <----- new speech (L_FRAME) ---->     *
     *                            |       |                                     *
     *                          speech    |                                     *
     *                                 new_speech                               *
     *--------------------------------------------------------------------------*/

    new_speech = old_speech + L_TOTAL - L_FRAME - L_FILT;         /* New speech     */
    speech = old_speech + L_TOTAL - L_FRAME - L_NEXT;             /* Present frame  */
    p_window = old_speech + L_TOTAL - L_WINDOW;

    exc = old_exc + PIT_MAX + L_INTERPOL;
    wsp = old_wsp + (PIT_MAX / OPL_DECIM);

    /* copy coder memory state into working space */
    Copy(st->old_speech, old_speech, L_TOTAL - L_FRAME);
    Copy(st->old_wsp, old_wsp, PIT_MAX / OPL_DECIM);
    Copy(st->old_exc, old_exc, PIT_MAX + L_INTERPOL);

    /*---------------------------------------------------------------*
     * Down sampling signal from 16kHz to 12.8kHz                    *
     * -> The signal is extended by L_FILT samples (padded to zero)  *
     * to avoid additional delay (L_FILT samples) in the coder.      *
     * The last L_FILT samples are approximated after decimation and *
     * are used (and windowed) only in autocorrelations.             *
     *---------------------------------------------------------------*/

    Decim_12k8(speech16k, L_FRAME16k, new_speech, st->mem_decim);

    /* last L_FILT samples for autocorrelation window */
    Copy(st->mem_decim, code, 2 * L_FILT16k);
    Set_zero(error, L_FILT16k);            /* set next sample to zero */
    Decim_12k8(error, L_FILT16k, new_speech + L_FRAME, code);

    /*---------------------------------------------------------------*
     * Perform 50Hz HP filtering of input signal.                    *
     *---------------------------------------------------------------*/

    HP50_12k8(new_speech, L_FRAME, st->mem_sig_in);

    /* last L_FILT samples for autocorrelation window */
    Copy(st->mem_sig_in, code, 6);
    HP50_12k8(new_speech + L_FRAME, L_FILT, code);

    /*---------------------------------------------------------------*
     * Perform fixed preemphasis through 1 - g z^-1                  *
     * Scale signal to get maximum of precision in filtering         *
     *---------------------------------------------------------------*/

    mu = PREEMPH_FAC >> 1;              /* Q15 --> Q14 */

    /* get max of new preemphased samples (L_FRAME+L_FILT) */
    L_tmp = new_speech[0] << 15;
    L_tmp -= (st->mem_preemph * mu)<<1;
    L_max = L_abs(L_tmp);

    for (i = 1; i < L_FRAME + L_FILT; i++)
    {
        L_tmp = new_speech[i] << 15;
        L_tmp -= (new_speech[i - 1] * mu)<<1;
        L_tmp = L_abs(L_tmp);
        if(L_tmp > L_max)
        {
            L_max = L_tmp;
        }
    }

    /* get scaling factor for new and previous samples */
    /* limit scaling to Q_MAX to keep dynamic for ringing in low signal */
    /* limit scaling to Q_MAX also to avoid a[0]<1 in syn_filt_32 */
    tmp = extract_h(L_max);
    if (tmp == 0)
    {
        shift = Q_MAX;
    } else
    {
        shift = norm_s(tmp) - 1;
        if (shift < 0)
        {
            shift = 0;
        }
        if (shift > Q_MAX)
        {
            shift = Q_MAX;
        }
    }
    Q_new = shift;
    if (Q_new > st->Q_max[0])
    {
        Q_new = st->Q_max[0];
    }
    if (Q_new > st->Q_max[1])
    {
        Q_new = st->Q_max[1];
    }
    exp = (Q_new - st->Q_old);
    st->Q_old = Q_new;
    st->Q_max[1] = st->Q_max[0];
    st->Q_max[0] = shift;

    /* preemphasis with scaling (L_FRAME+L_FILT) */
    tmp = new_speech[L_FRAME - 1];

    for (i = L_FRAME + L_FILT - 1; i > 0; i--)
    {
        L_tmp = new_speech[i] << 15;
        L_tmp -= (new_speech[i - 1] * mu)<<1;
        L_tmp = (L_tmp << Q_new);
        new_speech[i] = vo_round(L_tmp);
    }

    L_tmp = new_speech[0] << 15;
    L_tmp -= (st->mem_preemph * mu)<<1;
    L_tmp = (L_tmp << Q_new);
    new_speech[0] = vo_round(L_tmp);

    st->mem_preemph = tmp;

    /* scale previous samples and memory */

    Scale_sig(old_speech, L_TOTAL - L_FRAME - L_FILT, exp);
    Scale_sig(old_exc, PIT_MAX + L_INTERPOL, exp);
    Scale_sig(st->mem_syn, M, exp);
    Scale_sig(st->mem_decim2, 3, exp);
    Scale_sig(&(st->mem_wsp), 1, exp);
    Scale_sig(&(st->mem_w0), 1, exp);

    /*------------------------------------------------------------------------*
     *  Call VAD                                                              *
     *  Preemphesis scale down signal in low frequency and keep dynamic in HF.*
     *  Vad work slightly in futur (new_speech = speech + L_NEXT - L_FILT).   *
     *------------------------------------------------------------------------*/
    Copy(new_speech, buf, L_FRAME);

#ifdef ASM_OPT        /* asm optimization branch */
    Scale_sig_opt(buf, L_FRAME, 1 - Q_new);
#else
    Scale_sig(buf, L_FRAME, 1 - Q_new);
#endif

    vad_flag = wb_vad(st->vadSt, buf);          /* Voice Activity Detection */
    if (vad_flag == 0)
    {
        st->vad_hist = (st->vad_hist + 1);
    } else
    {
        st->vad_hist = 0;
    }

    /* DTX processing */
    if (allow_dtx != 0)
    {
        /* Note that mode may change here */
        tx_dtx_handler(st->dtx_encSt, vad_flag, mode);
        *ser_size = nb_of_bits[*mode];
    }

    if(*mode != MRDTX)
    {
        Parm_serial(vad_flag, 1, &prms);
    }
    /*------------------------------------------------------------------------*
     *  Perform LPC analysis                                                  *
     *  ~~~~~~~~~~~~~~~~~~~~                                                  *
     *   - autocorrelation + lag windowing                                    *
     *   - Levinson-durbin algorithm to find a[]                              *
     *   - convert a[] to isp[]                                               *
     *   - convert isp[] to isf[] for quantization                            *
     *   - quantize and code the isf[]                                        *
     *   - convert isf[] to isp[] for interpolation                           *
     *   - find the interpolated ISPs and convert to a[] for the 4 subframes  *
     *------------------------------------------------------------------------*/

    /* LP analysis centered at 4nd subframe */
    Autocorr(p_window, M, r_h, r_l);                        /* Autocorrelations */
    Lag_window(r_h, r_l);                                   /* Lag windowing    */
    Levinson(r_h, r_l, A, rc, st->mem_levinson);            /* Levinson Durbin  */
    Az_isp(A, ispnew, st->ispold);                          /* From A(z) to ISP */

    /* Find the interpolated ISPs and convert to a[] for all subframes */
    Int_isp(st->ispold, ispnew, interpol_frac, A);

    /* update ispold[] for the next frame */
    Copy(ispnew, st->ispold, M);

    /* Convert ISPs to frequency domain 0..6400 */
    Isp_isf(ispnew, isf, M);

    /* check resonance for pitch clipping algorithm */
    Gp_clip_test_isf(isf, st->gp_clip);

    /*----------------------------------------------------------------------*
     *  Perform PITCH_OL analysis                                           *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~                                           *
     * - Find the residual res[] for the whole speech frame                 *
     * - Find the weighted input speech wsp[] for the whole speech frame    *
     * - scale wsp[] to avoid overflow in pitch estimation                  *
     * - Find open loop pitch lag for whole speech frame                    *
     *----------------------------------------------------------------------*/
    p_A = A;
    for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
    {
        /* Weighting of LPC coefficients */
        Weight_a(p_A, Ap, GAMMA1, M);

#ifdef ASM_OPT                    /* asm optimization branch */
        Residu_opt(Ap, &speech[i_subfr], &wsp[i_subfr], L_SUBFR);
#else
        Residu(Ap, &speech[i_subfr], &wsp[i_subfr], L_SUBFR);
#endif

        p_A += (M + 1);
    }

    Deemph2(wsp, TILT_FAC, L_FRAME, &(st->mem_wsp));

    /* find maximum value on wsp[] for 12 bits scaling */
    max = 0;
    for (i = 0; i < L_FRAME; i++)
    {
        tmp = abs_s(wsp[i]);
        if(tmp > max)
        {
            max = tmp;
        }
    }
    tmp = st->old_wsp_max;
    if(max > tmp)
    {
        tmp = max;                         /* tmp = max(wsp_max, old_wsp_max) */
    }
    st->old_wsp_max = max;

    shift = norm_s(tmp) - 3;
    if (shift > 0)
    {
        shift = 0;                         /* shift = 0..-3 */
    }
    /* decimation of wsp[] to search pitch in LF and to reduce complexity */
    LP_Decim2(wsp, L_FRAME, st->mem_decim2);

    /* scale wsp[] in 12 bits to avoid overflow */
#ifdef  ASM_OPT                  /* asm optimization branch */
    Scale_sig_opt(wsp, L_FRAME / OPL_DECIM, shift);
#else
    Scale_sig(wsp, L_FRAME / OPL_DECIM, shift);
#endif
    /* scale old_wsp (warning: exp must be Q_new-Q_old) */
    exp = exp + (shift - st->old_wsp_shift);
    st->old_wsp_shift = shift;

    Scale_sig(old_wsp, PIT_MAX / OPL_DECIM, exp);
    Scale_sig(st->old_hp_wsp, PIT_MAX / OPL_DECIM, exp);

    scale_mem_Hp_wsp(st->hp_wsp_mem, exp);

    /* Find open loop pitch lag for whole speech frame */

    if(*ser_size == NBBITS_7k)
    {
        /* Find open loop pitch lag for whole speech frame */
        T_op = Pitch_med_ol(wsp, st, L_FRAME / OPL_DECIM);
    } else
    {
        /* Find open loop pitch lag for first 1/2 frame */
        T_op = Pitch_med_ol(wsp, st, (L_FRAME/2) / OPL_DECIM);
    }

    if(st->ol_gain > 19661)       /* 0.6 in Q15 */
    {
        st->old_T0_med = Med_olag(T_op, st->old_ol_lag);
        st->ada_w = 32767;
    } else
    {
        st->ada_w = vo_mult(st->ada_w, 29491);
    }

    if(st->ada_w < 26214)
        st->ol_wght_flg = 0;
    else
        st->ol_wght_flg = 1;

    wb_vad_tone_detection(st->vadSt, st->ol_gain);
    T_op *= OPL_DECIM;

    if(*ser_size != NBBITS_7k)
    {
        /* Find open loop pitch lag for second 1/2 frame */
        T_op2 = Pitch_med_ol(wsp + ((L_FRAME / 2) / OPL_DECIM), st, (L_FRAME/2) / OPL_DECIM);

        if(st->ol_gain > 19661)   /* 0.6 in Q15 */
        {
            st->old_T0_med = Med_olag(T_op2, st->old_ol_lag);
            st->ada_w = 32767;
        } else
        {
            st->ada_w = mult(st->ada_w, 29491);
        }

        if(st->ada_w < 26214)
            st->ol_wght_flg = 0;
        else
            st->ol_wght_flg = 1;

        wb_vad_tone_detection(st->vadSt, st->ol_gain);

        T_op2 *= OPL_DECIM;

    } else
    {
        T_op2 = T_op;
    }
    /*----------------------------------------------------------------------*
     *                              DTX-CNG                                 *
     *----------------------------------------------------------------------*/
    if(*mode == MRDTX)            /* CNG mode */
    {
        /* Buffer isf's and energy */
#ifdef ASM_OPT                   /* asm optimization branch */
        Residu_opt(&A[3 * (M + 1)], speech, exc, L_FRAME);
#else
        Residu(&A[3 * (M + 1)], speech, exc, L_FRAME);
#endif

        for (i = 0; i < L_FRAME; i++)
        {
            exc2[i] = shr(exc[i], Q_new);
        }

        L_tmp = 0;
        for (i = 0; i < L_FRAME; i++)
            L_tmp += (exc2[i] * exc2[i])<<1;

        L_tmp >>= 1;

        dtx_buffer(st->dtx_encSt, isf, L_tmp, codec_mode);

        /* Quantize and code the ISFs */
        dtx_enc(st->dtx_encSt, isf, exc2, &prms);

        /* Convert ISFs to the cosine domain */
        Isf_isp(isf, ispnew_q, M);
        Isp_Az(ispnew_q, Aq, M, 0);

        for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
        {
            corr_gain = synthesis(Aq, &exc2[i_subfr], 0, &speech16k[i_subfr * 5 / 4], st);
        }
        Copy(isf, st->isfold, M);

        /* reset speech coder memories */
        Reset_encoder(st, 0);

        /*--------------------------------------------------*
         * Update signal for next frame.                    *
         * -> save past of speech[] and wsp[].              *
         *--------------------------------------------------*/

        Copy(&old_speech[L_FRAME], st->old_speech, L_TOTAL - L_FRAME);
        Copy(&old_wsp[L_FRAME / OPL_DECIM], st->old_wsp, PIT_MAX / OPL_DECIM);

        return;
    }
    /*----------------------------------------------------------------------*
     *                               ACELP                                  *
     *----------------------------------------------------------------------*/

    /* Quantize and code the ISFs */

    if (*ser_size <= NBBITS_7k)
    {
        Qpisf_2s_36b(isf, isf, st->past_isfq, indice, 4);

        Parm_serial(indice[0], 8, &prms);
        Parm_serial(indice[1], 8, &prms);
        Parm_serial(indice[2], 7, &prms);
        Parm_serial(indice[3], 7, &prms);
        Parm_serial(indice[4], 6, &prms);
    } else
    {
        Qpisf_2s_46b(isf, isf, st->past_isfq, indice, 4);

        Parm_serial(indice[0], 8, &prms);
        Parm_serial(indice[1], 8, &prms);
        Parm_serial(indice[2], 6, &prms);
        Parm_serial(indice[3], 7, &prms);
        Parm_serial(indice[4], 7, &prms);
        Parm_serial(indice[5], 5, &prms);
        Parm_serial(indice[6], 5, &prms);
    }

    /* Check stability on isf : distance between old isf and current isf */

    L_tmp = 0;
    for (i = 0; i < M - 1; i++)
    {
        tmp = vo_sub(isf[i], st->isfold[i]);
        L_tmp += (tmp * tmp)<<1;
    }

    tmp = extract_h(L_shl2(L_tmp, 8));

    tmp = vo_mult(tmp, 26214);                /* tmp = L_tmp*0.8/256 */
    tmp = vo_sub(20480, tmp);                 /* 1.25 - tmp (in Q14) */

    stab_fac = shl(tmp, 1);

    if (stab_fac < 0)
    {
        stab_fac = 0;
    }
    Copy(isf, st->isfold, M);

    /* Convert ISFs to the cosine domain */
    Isf_isp(isf, ispnew_q, M);

    if (st->first_frame != 0)
    {
        st->first_frame = 0;
        Copy(ispnew_q, st->ispold_q, M);
    }
    /* Find the interpolated ISPs and convert to a[] for all subframes */

    Int_isp(st->ispold_q, ispnew_q, interpol_frac, Aq);

    /* update ispold[] for the next frame */
    Copy(ispnew_q, st->ispold_q, M);

    p_Aq = Aq;
    for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
    {
#ifdef ASM_OPT               /* asm optimization branch */
        Residu_opt(p_Aq, &speech[i_subfr], &exc[i_subfr], L_SUBFR);
#else
        Residu(p_Aq, &speech[i_subfr], &exc[i_subfr], L_SUBFR);
#endif
        p_Aq += (M + 1);
    }

    /* Buffer isf's and energy for dtx on non-speech frame */
    if (vad_flag == 0)
    {
        for (i = 0; i < L_FRAME; i++)
        {
            exc2[i] = exc[i] >> Q_new;
        }
        L_tmp = 0;
        for (i = 0; i < L_FRAME; i++) {
            Word32 tmp = L_mult(exc2[i], exc2[i]); // (exc2[i] * exc2[i])<<1;
            L_tmp = L_add(L_tmp, tmp);
        }
        L_tmp >>= 1;

        dtx_buffer(st->dtx_encSt, isf, L_tmp, codec_mode);
    }
    /* range for closed loop pitch search in 1st subframe */

    T0_min = T_op - 8;
    if (T0_min < PIT_MIN)
    {
        T0_min = PIT_MIN;
    }
    T0_max = (T0_min + 15);

    if(T0_max > PIT_MAX)
    {
        T0_max = PIT_MAX;
        T0_min = T0_max - 15;
    }
    /*------------------------------------------------------------------------*
     *          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.               *
     *     - 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                                           *
     *     - find 2 lt prediction (with / without LP filter for lt pred)      *
     *     - find 2 pitch gains and choose the best lt prediction.            *
     *     - find target vector for codebook search                           *
     *     - update the impulse response h1[] for codebook search             *
     *     - correlation between target vector and impulse response           *
     *     - codebook search and encoding                                     *
     *     - VQ of pitch and codebook gains                                   *
     *     - find voicing factor and tilt of code for next subframe.          *
     *     - update states of weighting filter                                *
     *     - find excitation and synthesis speech                             *
     *------------------------------------------------------------------------*/
    p_A = A;
    p_Aq = Aq;
    for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR)
    {
        pit_flag = i_subfr;
        if ((i_subfr == 2 * L_SUBFR) && (*ser_size > NBBITS_7k))
        {
            pit_flag = 0;
            /* range for closed loop pitch search in 3rd subframe */
            T0_min = (T_op2 - 8);

            if (T0_min < PIT_MIN)
            {
                T0_min = PIT_MIN;
            }
            T0_max = (T0_min + 15);
            if (T0_max > PIT_MAX)
            {
                T0_max = PIT_MAX;
                T0_min = (T0_max - 15);
            }
        }
        /*-----------------------------------------------------------------------*
         *                                                                       *
         *        Find the target vector for pitch search:                       *
         *        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                        *
         *                                                                       *
         *             |------|  res[n]                                          *
         * speech[n]---| A(z) |--------                                          *
         *             |------|       |   |--------| error[n]  |------|          *
         *                   zero -- (-)--| 1/A(z) |-----------| W(z) |-- target *
         *                   exc          |--------|           |------|          *
         *                                                                       *
         * Instead of subtracting the zero-input response of filters from        *
         * the weighted input speech, the above configuration is used to         *
         * compute the target vector.                                            *
         *                                                                       *
         *-----------------------------------------------------------------------*/

        for (i = 0; i < M; i++)
        {
            error[i] = vo_sub(speech[i + i_subfr - M], st->mem_syn[i]);
        }

#ifdef ASM_OPT              /* asm optimization branch */
        Residu_opt(p_Aq, &speech[i_subfr], &exc[i_subfr], L_SUBFR);
#else
        Residu(p_Aq, &speech[i_subfr], &exc[i_subfr], L_SUBFR);
#endif
        Syn_filt(p_Aq, &exc[i_subfr], error + M, L_SUBFR, error, 0);
        Weight_a(p_A, Ap, GAMMA1, M);

#ifdef ASM_OPT             /* asm optimization branch */
        Residu_opt(Ap, error + M, xn, L_SUBFR);
#else
        Residu(Ap, error + M, xn, L_SUBFR);
#endif
        Deemph2(xn, TILT_FAC, L_SUBFR, &(st->mem_w0));

        /*----------------------------------------------------------------------*
         * Find approx. target in residual domain "cn[]" for inovation search.  *
         *----------------------------------------------------------------------*/
        /* first half: xn[] --> cn[] */
        Set_zero(code, M);
        Copy(xn, code + M, L_SUBFR / 2);
        tmp = 0;
        Preemph2(code + M, TILT_FAC, L_SUBFR / 2, &tmp);
        Weight_a(p_A, Ap, GAMMA1, M);
        Syn_filt(Ap,code + M, code + M, L_SUBFR / 2, code, 0);

#ifdef ASM_OPT                /* asm optimization branch */
        Residu_opt(p_Aq,code + M, cn, L_SUBFR / 2);
#else
        Residu(p_Aq,code + M, cn, L_SUBFR / 2);
#endif

        /* second half: res[] --> cn[] (approximated and faster) */
        Copy(&exc[i_subfr + (L_SUBFR / 2)], cn + (L_SUBFR / 2), L_SUBFR / 2);

        /*---------------------------------------------------------------*
         * Compute impulse response, h1[], of weighted synthesis filter  *
         *---------------------------------------------------------------*/

        Set_zero(error, M + L_SUBFR);
        Weight_a(p_A, error + M, GAMMA1, M);

        vo_p0 = error+M;
        vo_p3 = h1;
        for (i = 0; i < L_SUBFR; i++)
        {
            L_tmp = *vo_p0 << 14;        /* x4 (Q12 to Q14) */
            vo_p1 = p_Aq + 1;
            vo_p2 = vo_p0-1;
            for (j = 1; j <= M/4; j++)
            {
                L_tmp = L_sub(L_tmp, *vo_p1++ * *vo_p2--);
                L_tmp = L_sub(L_tmp, *vo_p1++ * *vo_p2--);
                L_tmp = L_sub(L_tmp, *vo_p1++ * *vo_p2--);
                L_tmp = L_sub(L_tmp, *vo_p1++ * *vo_p2--);
            }
            *vo_p3++ = *vo_p0++ = vo_round((L_tmp <<4));
        }
        /* deemph without division by 2 -> Q14 to Q15 */
        tmp = 0;
        Deemph2(h1, TILT_FAC, L_SUBFR, &tmp);   /* h1 in Q14 */

        /* h2 in Q12 for codebook search */
        Copy(h1, h2, L_SUBFR);

        /*---------------------------------------------------------------*
         * scale xn[] and h1[] to avoid overflow in dot_product12()      *
         *---------------------------------------------------------------*/
#ifdef  ASM_OPT                  /* asm optimization branch */
        Scale_sig_opt(h2, L_SUBFR, -2);
        Scale_sig_opt(xn, L_SUBFR, shift);     /* scaling of xn[] to limit dynamic at 12 bits */
        Scale_sig_opt(h1, L_SUBFR, 1 + shift);  /* set h1[] in Q15 with scaling for convolution */
#else
        Scale_sig(h2, L_SUBFR, -2);
        Scale_sig(xn, L_SUBFR, shift);     /* scaling of xn[] to limit dynamic at 12 bits */
        Scale_sig(h1, L_SUBFR, 1 + shift);  /* set h1[] in Q15 with scaling for convolution */
#endif
        /*----------------------------------------------------------------------*
         *                 Closed-loop fractional pitch search                  *
         *----------------------------------------------------------------------*/
        /* find closed loop fractional pitch  lag */
        if(*ser_size <= NBBITS_9k)
        {
            T0 = Pitch_fr4(&exc[i_subfr], xn, h1, T0_min, T0_max, &T0_frac,
                    pit_flag, PIT_MIN, PIT_FR1_8b, L_SUBFR);

            /* encode pitch lag */
            if (pit_flag == 0)             /* if 1st/3rd subframe */
            {
                /*--------------------------------------------------------------*
                 * The pitch range for the 1st/3rd subframe is encoded with     *
                 * 8 bits and is divided as follows:                            *
                 *   PIT_MIN to PIT_FR1-1  resolution 1/2 (frac = 0 or 2)       *
                 *   PIT_FR1 to PIT_MAX    resolution 1   (frac = 0)            *
                 *--------------------------------------------------------------*/
                if (T0 < PIT_FR1_8b)
                {
                    index = ((T0 << 1) + (T0_frac >> 1) - (PIT_MIN<<1));
                } else
                {
                    index = ((T0 - PIT_FR1_8b) + ((PIT_FR1_8b - PIT_MIN)*2));
                }

                Parm_serial(index, 8, &prms);

                /* find T0_min and T0_max for subframe 2 and 4 */
                T0_min = (T0 - 8);
                if (T0_min < PIT_MIN)
                {
                    T0_min = PIT_MIN;
                }
                T0_max = T0_min + 15;
                if (T0_max > PIT_MAX)
                {
                    T0_max = PIT_MAX;
                    T0_min = (T0_max - 15);
                }
            } else
            {                              /* if subframe 2 or 4 */
                /*--------------------------------------------------------------*
                 * The pitch range for subframe 2 or 4 is encoded with 5 bits:  *
                 *   T0_min  to T0_max     resolution 1/2 (frac = 0 or 2)       *
                 *--------------------------------------------------------------*/
                i = (T0 - T0_min);
                index = (i << 1) + (T0_frac >> 1);

                Parm_serial(index, 5, &prms);
            }
        } else
        {
            T0 = Pitch_fr4(&exc[i_subfr], xn, h1, T0_min, T0_max, &T0_frac,
                    pit_flag, PIT_FR2, PIT_FR1_9b, L_SUBFR);

            /* encode pitch lag */
            if (pit_flag == 0)             /* if 1st/3rd subframe */
            {
                /*--------------------------------------------------------------*
                 * The pitch range for the 1st/3rd subframe is encoded with     *
                 * 9 bits and is divided as follows:                            *
                 *   PIT_MIN to PIT_FR2-1  resolution 1/4 (frac = 0,1,2 or 3)   *
                 *   PIT_FR2 to PIT_FR1-1  resolution 1/2 (frac = 0 or 1)       *
                 *   PIT_FR1 to PIT_MAX    resolution 1   (frac = 0)            *
                 *--------------------------------------------------------------*/

                if (T0 < PIT_FR2)
                {
                    index = ((T0 << 2) + T0_frac) - (PIT_MIN << 2);
                } else if(T0 < PIT_FR1_9b)
                {
                    index = ((((T0 << 1) + (T0_frac >> 1)) - (PIT_FR2<<1)) + ((PIT_FR2 - PIT_MIN)<<2));
                } else
                {
                    index = (((T0 - PIT_FR1_9b) + ((PIT_FR2 - PIT_MIN)<<2)) + ((PIT_FR1_9b - PIT_FR2)<<1));
                }

                Parm_serial(index, 9, &prms);

                /* find T0_min and T0_max for subframe 2 and 4 */

                T0_min = (T0 - 8);
                if (T0_min < PIT_MIN)
                {
                    T0_min = PIT_MIN;
                }
                T0_max = T0_min + 15;

                if (T0_max > PIT_MAX)
                {
                    T0_max = PIT_MAX;
                    T0_min = (T0_max - 15);
                }
            } else
            {                              /* if subframe 2 or 4 */
                /*--------------------------------------------------------------*
                 * The pitch range for subframe 2 or 4 is encoded with 6 bits:  *
                 *   T0_min  to T0_max     resolution 1/4 (frac = 0,1,2 or 3)   *
                 *--------------------------------------------------------------*/
                i = (T0 - T0_min);
                index = (i << 2) + T0_frac;
                Parm_serial(index, 6, &prms);
            }
        }

        /*-----------------------------------------------------------------*
         * Gain clipping test to avoid unstable synthesis on frame erasure *
         *-----------------------------------------------------------------*/

        clip_gain = 0;
        if((st->gp_clip[0] < 154) && (st->gp_clip[1] > 14746))
            clip_gain = 1;

        /*-----------------------------------------------------------------*
         * - find unity gain pitch excitation (adaptive codebook entry)    *
         *   with fractional interpolation.                                *
         * - find filtered pitch exc. y1[]=exc[] convolved with h1[])      *
         * - compute pitch gain1                                           *
         *-----------------------------------------------------------------*/
        /* find pitch exitation */
#ifdef ASM_OPT                  /* asm optimization branch */
        pred_lt4_asm(&exc[i_subfr], T0, T0_frac, L_SUBFR + 1);
#else
        Pred_lt4(&exc[i_subfr], T0, T0_frac, L_SUBFR + 1);
#endif
        if (*ser_size > NBBITS_9k)
        {
#ifdef ASM_OPT                   /* asm optimization branch */
            Convolve_asm(&exc[i_subfr], h1, y1, L_SUBFR);
#else
            Convolve(&exc[i_subfr], h1, y1, L_SUBFR);
#endif
            gain1 = G_pitch(xn, y1, g_coeff, L_SUBFR);
            /* clip gain if necessary to avoid problem at decoder */
            if ((clip_gain != 0) && (gain1 > GP_CLIP))
            {
                gain1 = GP_CLIP;
            }
            /* find energy of new target xn2[] */
            Updt_tar(xn, dn, y1, gain1, L_SUBFR);       /* dn used temporary */
        } else
        {
            gain1 = 0;
        }
        /*-----------------------------------------------------------------*
         * - find pitch excitation filtered by 1st order LP filter.        *
         * - find filtered pitch exc. y2[]=exc[] convolved with h1[])      *
         * - compute pitch gain2                                           *
         *-----------------------------------------------------------------*/
        /* find pitch excitation with lp filter */
        vo_p0 = exc + i_subfr-1;
        vo_p1 = code;
        /* find pitch excitation with lp filter */
        for (i = 0; i < L_SUBFR/2; i++)
        {
            L_tmp = 5898 * *vo_p0++;
            L_tmp1 = 5898 * *vo_p0;
            L_tmp += 20972 * *vo_p0++;
            L_tmp1 += 20972 * *vo_p0++;
            L_tmp1 += 5898 * *vo_p0--;
            L_tmp += 5898 * *vo_p0;
            *vo_p1++ = (L_tmp + 0x4000)>>15;
            *vo_p1++ = (L_tmp1 + 0x4000)>>15;
        }

#ifdef ASM_OPT                 /* asm optimization branch */
        Convolve_asm(code, h1, y2, L_SUBFR);
#else
        Convolve(code, h1, y2, L_SUBFR);
#endif

        gain2 = G_pitch(xn, y2, g_coeff2, L_SUBFR);

        /* clip gain if necessary to avoid problem at decoder */
        if ((clip_gain != 0) && (gain2 > GP_CLIP))
        {
            gain2 = GP_CLIP;
        }
        /* find energy of new target xn2[] */
        Updt_tar(xn, xn2, y2, gain2, L_SUBFR);
        /*-----------------------------------------------------------------*
         * use the best prediction (minimise quadratic error).             *
         *-----------------------------------------------------------------*/
        select = 0;
        if(*ser_size > NBBITS_9k)
        {
            L_tmp = 0L;
            vo_p0 = dn;
            vo_p1 = xn2;
            for (i = 0; i < L_SUBFR/2; i++)
            {
                L_tmp = L_add(L_tmp, *vo_p0 * *vo_p0);
                vo_p0++;
                L_tmp = L_sub(L_tmp, *vo_p1 * *vo_p1);
                vo_p1++;
                L_tmp = L_add(L_tmp, *vo_p0 * *vo_p0);
                vo_p0++;
                L_tmp = L_sub(L_tmp, *vo_p1 * *vo_p1);
                vo_p1++;
            }

            if (L_tmp <= 0)
            {
                select = 1;
            }
            Parm_serial(select, 1, &prms);
        }
        if (select == 0)
        {
            /* use the lp filter for pitch excitation prediction */
            gain_pit = gain2;
            Copy(code, &exc[i_subfr], L_SUBFR);
            Copy(y2, y1, L_SUBFR);
            Copy(g_coeff2, g_coeff, 4);
        } else
        {
            /* no filter used for pitch excitation prediction */
            gain_pit = gain1;
            Copy(dn, xn2, L_SUBFR);        /* target vector for codebook search */
        }
        /*-----------------------------------------------------------------*
         * - update cn[] for codebook search                               *
         *-----------------------------------------------------------------*/
        Updt_tar(cn, cn, &exc[i_subfr], gain_pit, L_SUBFR);

#ifdef  ASM_OPT                           /* asm optimization branch */
        Scale_sig_opt(cn, L_SUBFR, shift);     /* scaling of cn[] to limit dynamic at 12 bits */
#else
        Scale_sig(cn, L_SUBFR, shift);     /* scaling of cn[] to limit dynamic at 12 bits */
#endif
        /*-----------------------------------------------------------------*
         * - include fixed-gain pitch contribution into impulse resp. h1[] *
         *-----------------------------------------------------------------*/
        tmp = 0;
        Preemph(h2, st->tilt_code, L_SUBFR, &tmp);

        if (T0_frac > 2)
            T0 = (T0 + 1);
        Pit_shrp(h2, T0, PIT_SHARP, L_SUBFR);
        /*-----------------------------------------------------------------*
         * - Correlation between target xn2[] and impulse response h1[]    *
         * - Innovative codebook search                                    *
         *-----------------------------------------------------------------*/
        cor_h_x(h2, xn2, dn);
        if (*ser_size <= NBBITS_7k)
        {
            ACELP_2t64_fx(dn, cn, h2, code, y2, indice);

            Parm_serial(indice[0], 12, &prms);
        } else if(*ser_size <= NBBITS_9k)
        {
            ACELP_4t64_fx(dn, cn, h2, code, y2, 20, *ser_size, indice);

            Parm_serial(indice[0], 5, &prms);
            Parm_serial(indice[1], 5, &prms);
            Parm_serial(indice[2], 5, &prms);
            Parm_serial(indice[3], 5, &prms);
        } else if(*ser_size <= NBBITS_12k)
        {
            ACELP_4t64_fx(dn, cn, h2, code, y2, 36, *ser_size, indice);

            Parm_serial(indice[0], 9, &prms);
            Parm_serial(indice[1], 9, &prms);
            Parm_serial(indice[2], 9, &prms);
            Parm_serial(indice[3], 9, &prms);
        } else if(*ser_size <= NBBITS_14k)
        {
            ACELP_4t64_fx(dn, cn, h2, code, y2, 44, *ser_size, indice);

            Parm_serial(indice[0], 13, &prms);
            Parm_serial(indice[1], 13, &prms);
            Parm_serial(indice[2], 9, &prms);
            Parm_serial(indice[3], 9, &prms);
        } else if(*ser_size <= NBBITS_16k)
        {
            ACELP_4t64_fx(dn, cn, h2, code, y2, 52, *ser_size, indice);

            Parm_serial(indice[0], 13, &prms);
            Parm_serial(indice[1], 13, &prms);
            Parm_serial(indice[2], 13, &prms);
            Parm_serial(indice[3], 13, &prms);
        } else if(*ser_size <= NBBITS_18k)
        {
            ACELP_4t64_fx(dn, cn, h2, code, y2, 64, *ser_size, indice);

            Parm_serial(indice[0], 2, &prms);
            Parm_serial(indice[1], 2, &prms);
            Parm_serial(indice[2], 2, &prms);
            Parm_serial(indice[3], 2, &prms);
            Parm_serial(indice[4], 14, &prms);
            Parm_serial(indice[5], 14, &prms);
            Parm_serial(indice[6], 14, &prms);
            Parm_serial(indice[7], 14, &prms);
        } else if(*ser_size <= NBBITS_20k)
        {
            ACELP_4t64_fx(dn, cn, h2, code, y2, 72, *ser_size, indice);

            Parm_serial(indice[0], 10, &prms);
            Parm_serial(indice[1], 10, &prms);
            Parm_serial(indice[2], 2, &prms);
            Parm_serial(indice[3], 2, &prms);
            Parm_serial(indice[4], 10, &prms);
            Parm_serial(indice[5], 10, &prms);
            Parm_serial(indice[6], 14, &prms);
            Parm_serial(indice[7], 14, &prms);
        } else
        {
            ACELP_4t64_fx(dn, cn, h2, code, y2, 88, *ser_size, indice);

            Parm_serial(indice[0], 11, &prms);
            Parm_serial(indice[1], 11, &prms);
            Parm_serial(indice[2], 11, &prms);
            Parm_serial(indice[3], 11, &prms);
            Parm_serial(indice[4], 11, &prms);
            Parm_serial(indice[5], 11, &prms);
            Parm_serial(indice[6], 11, &prms);
            Parm_serial(indice[7], 11, &prms);
        }
        /*-------------------------------------------------------*
         * - Add the fixed-gain pitch contribution to code[].    *
         *-------------------------------------------------------*/
        tmp = 0;
        Preemph(code, st->tilt_code, L_SUBFR, &tmp);
        Pit_shrp(code, T0, PIT_SHARP, L_SUBFR);
        /*----------------------------------------------------------*
         *  - Compute the fixed codebook gain                       *
         *  - quantize fixed codebook gain                          *
         *----------------------------------------------------------*/
        if(*ser_size <= NBBITS_9k)
        {
            index = Q_gain2(xn, y1, Q_new + shift, y2, code, g_coeff, L_SUBFR, 6,
                    &gain_pit, &L_gain_code, clip_gain, st->qua_gain);
            Parm_serial(index, 6, &prms);
        } else
        {
            index = Q_gain2(xn, y1, Q_new + shift, y2, code, g_coeff, L_SUBFR, 7,
                    &gain_pit, &L_gain_code, clip_gain, st->qua_gain);
            Parm_serial(index, 7, &prms);
        }
        /* test quantized gain of pitch for pitch clipping algorithm */
        Gp_clip_test_gain_pit(gain_pit, st->gp_clip);

        L_tmp = L_shl(L_gain_code, Q_new);
        gain_code = extract_h(L_add(L_tmp, 0x8000));

        /*----------------------------------------------------------*
         * Update parameters for the next subframe.                 *
         * - tilt of code: 0.0 (unvoiced) to 0.5 (voiced)           *
         *----------------------------------------------------------*/
        /* find voice factor in Q15 (1=voiced, -1=unvoiced) */
        Copy(&exc[i_subfr], exc2, L_SUBFR);

#ifdef ASM_OPT                           /* asm optimization branch */
        Scale_sig_opt(exc2, L_SUBFR, shift);
#else
        Scale_sig(exc2, L_SUBFR, shift);
#endif
        voice_fac = voice_factor(exc2, shift, gain_pit, code, gain_code, L_SUBFR);
        /* tilt of code for next subframe: 0.5=voiced, 0=unvoiced */
        st->tilt_code = ((voice_fac >> 2) + 8192);
        /*------------------------------------------------------*
         * - Update filter's memory "mem_w0" for finding the    *
         *   target vector in the next subframe.                *
         * - Find the total excitation                          *
         * - Find synthesis speech to update mem_syn[].         *
         *------------------------------------------------------*/

        /* y2 in Q9, gain_pit in Q14 */
        L_tmp = L_mult(gain_code, y2[L_SUBFR - 1]);
        L_tmp = L_shl(L_tmp, (5 + shift));
        L_tmp = L_negate(L_tmp);
        L_tmp += (xn[L_SUBFR - 1] * 16384)<<1;
        L_tmp -= (y1[L_SUBFR - 1] * gain_pit)<<1;
        L_tmp = L_shl(L_tmp, (1 - shift));
        st->mem_w0 = extract_h(L_add(L_tmp, 0x8000));

        if (*ser_size >= NBBITS_24k)
            Copy(&exc[i_subfr], exc2, L_SUBFR);

        for (i = 0; i < L_SUBFR; i++)
        {
            Word32 tmp;
            /* code in Q9, gain_pit in Q14 */
            L_tmp = L_mult(gain_code, code[i]);
            L_tmp = L_shl(L_tmp, 5);
            tmp = L_mult(exc[i + i_subfr], gain_pit); // (exc[i + i_subfr] * gain_pit)<<1
            L_tmp = L_add(L_tmp, tmp);
            L_tmp = L_shl2(L_tmp, 1);
            exc[i + i_subfr] = extract_h(L_add(L_tmp, 0x8000));
        }

        Syn_filt(p_Aq,&exc[i_subfr], synth, L_SUBFR, st->mem_syn, 1);

        if(*ser_size >= NBBITS_24k)
        {
            /*------------------------------------------------------------*
             * phase dispersion to enhance noise in low bit rate          *
             *------------------------------------------------------------*/
            /* L_gain_code in Q16 */
            VO_L_Extract(L_gain_code, &gain_code, &gain_code_lo);

            /*------------------------------------------------------------*
             * noise enhancer                                             *
             * ~~~~~~~~~~~~~~                                             *
             * - Enhance excitation on noise. (modify gain of code)       *
             *   If signal is noisy and LPC filter is stable, move gain   *
             *   of code 1.5 dB toward gain of code threshold.            *
             *   This decrease by 3 dB noise energy variation.            *
             *------------------------------------------------------------*/
            tmp = (16384 - (voice_fac >> 1));        /* 1=unvoiced, 0=voiced */
            fac = vo_mult(stab_fac, tmp);
            L_tmp = L_gain_code;
            if(L_tmp < st->L_gc_thres)
            {
                L_tmp = vo_L_add(L_tmp, Mpy_32_16(gain_code, gain_code_lo, 6226));
                if(L_tmp > st->L_gc_thres)
                {
                    L_tmp = st->L_gc_thres;
                }
            } else
            {
                L_tmp = Mpy_32_16(gain_code, gain_code_lo, 27536);
                if(L_tmp < st->L_gc_thres)
                {
                    L_tmp = st->L_gc_thres;
                }
            }
            st->L_gc_thres = L_tmp;

            L_gain_code = Mpy_32_16(gain_code, gain_code_lo, (32767 - fac));
            VO_L_Extract(L_tmp, &gain_code, &gain_code_lo);
            L_gain_code = vo_L_add(L_gain_code, Mpy_32_16(gain_code, gain_code_lo, fac));

            /*------------------------------------------------------------*
             * pitch enhancer                                             *
             * ~~~~~~~~~~~~~~                                             *
             * - Enhance excitation on voice. (HP filtering of code)      *
             *   On voiced signal, filtering of code by a smooth fir HP   *
             *   filter to decrease energy of code in low frequency.      *
             *------------------------------------------------------------*/

            tmp = ((voice_fac >> 3) + 4096); /* 0.25=voiced, 0=unvoiced */

            L_tmp = L_deposit_h(code[0]);
            L_tmp -= (code[1] * tmp)<<1;
            code2[0] = vo_round(L_tmp);

            for (i = 1; i < L_SUBFR - 1; i++)
            {
                L_tmp = L_deposit_h(code[i]);
                L_tmp -= (code[i + 1] * tmp)<<1;
                L_tmp -= (code[i - 1] * tmp)<<1;
                code2[i] = vo_round(L_tmp);
            }

            L_tmp = L_deposit_h(code[L_SUBFR - 1]);
            L_tmp -= (code[L_SUBFR - 2] * tmp)<<1;
            code2[L_SUBFR - 1] = vo_round(L_tmp);

            /* build excitation */
            gain_code = vo_round(L_shl(L_gain_code, Q_new));

            for (i = 0; i < L_SUBFR; i++)
            {
                L_tmp = L_mult(code2[i], gain_code);
                L_tmp = L_shl(L_tmp, 5);
                L_tmp = L_add(L_tmp, L_mult(exc2[i], gain_pit));
                L_tmp = L_shl(L_tmp, 1);
                exc2[i] = voround(L_tmp);
            }

            corr_gain = synthesis(p_Aq, exc2, Q_new, &speech16k[i_subfr * 5 / 4], st);
            Parm_serial(corr_gain, 4, &prms);
        }
        p_A += (M + 1);
        p_Aq += (M + 1);
    }                                      /* end of subframe loop */

    /*--------------------------------------------------*
     * Update signal for next frame.                    *
     * -> save past of speech[], wsp[] and exc[].       *
     *--------------------------------------------------*/
    Copy(&old_speech[L_FRAME], st->old_speech, L_TOTAL - L_FRAME);
    Copy(&old_wsp[L_FRAME / OPL_DECIM], st->old_wsp, PIT_MAX / OPL_DECIM);
    Copy(&old_exc[L_FRAME], st->old_exc, PIT_MAX + L_INTERPOL);
    return;
}

/*-----------------------------------------------------*
* Function synthesis()                                *
*                                                     *
* Synthesis of signal at 16kHz with HF extension.     *
*                                                     *
*-----------------------------------------------------*/

static Word16 synthesis(
        Word16 Aq[],                          /* A(z)  : quantized Az               */
        Word16 exc[],                         /* (i)   : excitation at 12kHz        */
        Word16 Q_new,                         /* (i)   : scaling performed on exc   */
        Word16 synth16k[],                    /* (o)   : 16kHz synthesis signal     */
        Coder_State * st                      /* (i/o) : State structure            */
        )
{
    Word16 fac, tmp, exp;
    Word16 ener, exp_ener;
    Word32 L_tmp, i;

    Word16 synth_hi[M + L_SUBFR], synth_lo[M + L_SUBFR];
    Word16 synth[L_SUBFR];
    Word16 HF[L_SUBFR16k];                 /* High Frequency vector      */
    Word16 Ap[M + 1];

    Word16 HF_SP[L_SUBFR16k];              /* High Frequency vector (from original signal) */

    Word16 HP_est_gain, HP_calc_gain, HP_corr_gain;
    Word16 dist_min, dist;
    Word16 HP_gain_ind = 0;
    Word16 gain1, gain2;
    Word16 weight1, weight2;

    /*------------------------------------------------------------*
     * speech synthesis                                           *
     * ~~~~~~~~~~~~~~~~                                           *
     * - Find synthesis speech corresponding to exc2[].           *
     * - Perform fixed deemphasis and hp 50hz filtering.          *
     * - Oversampling from 12.8kHz to 16kHz.                      *
     *------------------------------------------------------------*/
    Copy(st->mem_syn_hi, synth_hi, M);
    Copy(st->mem_syn_lo, synth_lo, M);

#ifdef ASM_OPT                 /* asm optimization branch */
    Syn_filt_32_asm(Aq, M, exc, Q_new, synth_hi + M, synth_lo + M, L_SUBFR);
#else
    Syn_filt_32(Aq, M, exc, Q_new, synth_hi + M, synth_lo + M, L_SUBFR);
#endif

    Copy(synth_hi + L_SUBFR, st->mem_syn_hi, M);
    Copy(synth_lo + L_SUBFR, st->mem_syn_lo, M);

#ifdef ASM_OPT                 /* asm optimization branch */
    Deemph_32_asm(synth_hi + M, synth_lo + M, synth, &(st->mem_deemph));
#else
    Deemph_32(synth_hi + M, synth_lo + M, synth, PREEMPH_FAC, L_SUBFR, &(st->mem_deemph));
#endif

    HP50_12k8(synth, L_SUBFR, st->mem_sig_out);

    /* Original speech signal as reference for high band gain quantisation */
    for (i = 0; i < L_SUBFR16k; i++)
    {
        HF_SP[i] = synth16k[i];
    }

    /*------------------------------------------------------*
     * HF noise synthesis                                   *
     * ~~~~~~~~~~~~~~~~~~                                   *
     * - Generate HF noise between 5.5 and 7.5 kHz.         *
     * - Set energy of noise according to synthesis tilt.   *
     *     tilt > 0.8 ==> - 14 dB (voiced)                  *
     *     tilt   0.5 ==> - 6 dB  (voiced or noise)         *
     *     tilt < 0.0 ==>   0 dB  (noise)                   *
     *------------------------------------------------------*/
    /* generate white noise vector */
    for (i = 0; i < L_SUBFR16k; i++)
    {
        HF[i] = Random(&(st->seed2))>>3;
    }
    /* energy of excitation */
#ifdef ASM_OPT                    /* asm optimization branch */
    Scale_sig_opt(exc, L_SUBFR, -3);
    Q_new = Q_new - 3;
    ener = extract_h(Dot_product12_asm(exc, exc, L_SUBFR, &exp_ener));
#else
    Scale_sig(exc, L_SUBFR, -3);
    Q_new = Q_new - 3;
    ener = extract_h(Dot_product12(exc, exc, L_SUBFR, &exp_ener));
#endif

    exp_ener = exp_ener - (Q_new + Q_new);
    /* set energy of white noise to energy of excitation */
#ifdef ASM_OPT              /* asm optimization branch */
    tmp = extract_h(Dot_product12_asm(HF, HF, L_SUBFR16k, &exp));
#else
    tmp = extract_h(Dot_product12(HF, HF, L_SUBFR16k, &exp));
#endif

    if(tmp > ener)
    {
        tmp = (tmp >> 1);                 /* Be sure tmp < ener */
        exp = (exp + 1);
    }
    L_tmp = L_deposit_h(div_s(tmp, ener)); /* result is normalized */
    exp = (exp - exp_ener);
    Isqrt_n(&L_tmp, &exp);
    L_tmp = L_shl(L_tmp, (exp + 1));       /* L_tmp x 2, L_tmp in Q31 */
    tmp = extract_h(L_tmp);                /* tmp = 2 x sqrt(ener_exc/ener_hf) */

    for (i = 0; i < L_SUBFR16k; i++)
    {
        HF[i] = vo_mult(HF[i], tmp);
    }

    /* find tilt of synthesis speech (tilt: 1=voiced, -1=unvoiced) */
    HP400_12k8(synth, L_SUBFR, st->mem_hp400);

    L_tmp = 1L;
    for (i = 0; i < L_SUBFR; i++)
        L_tmp += (synth[i] * synth[i])<<1;

    exp = norm_l(L_tmp);
    ener = extract_h(L_tmp << exp);   /* ener = r[0] */

    L_tmp = 1L;
    for (i = 1; i < L_SUBFR; i++)
        L_tmp +=(synth[i] * synth[i - 1])<<1;

    tmp = extract_h(L_tmp << exp);    /* tmp = r[1] */

    if (tmp > 0)
    {
        fac = div_s(tmp, ener);
    } else
    {
        fac = 0;
    }

    /* modify energy of white noise according to synthesis tilt */
    gain1 = 32767 - fac;
    gain2 = vo_mult(gain1, 20480);
    gain2 = shl(gain2, 1);

    if (st->vad_hist > 0)
    {
        weight1 = 0;
        weight2 = 32767;
    } else
    {
        weight1 = 32767;
        weight2 = 0;
    }
    tmp = vo_mult(weight1, gain1);
    tmp = add1(tmp, vo_mult(weight2, gain2));

    if (tmp != 0)
    {
        tmp = (tmp + 1);
    }
    HP_est_gain = tmp;

    if(HP_est_gain < 3277)
    {
        HP_est_gain = 3277;                /* 0.1 in Q15 */
    }
    /* synthesis of noise: 4.8kHz..5.6kHz --> 6kHz..7kHz */
    Weight_a(Aq, Ap, 19661, M);            /* fac=0.6 */

#ifdef ASM_OPT                /* asm optimization branch */
    Syn_filt_asm(Ap, HF, HF, st->mem_syn_hf);
    /* noise High Pass filtering (1ms of delay) */
    Filt_6k_7k_asm(HF, L_SUBFR16k, st->mem_hf);
    /* filtering of the original signal */
    Filt_6k_7k_asm(HF_SP, L_SUBFR16k, st->mem_hf2);

    /* check the gain difference */
    Scale_sig_opt(HF_SP, L_SUBFR16k, -1);
    ener = extract_h(Dot_product12_asm(HF_SP, HF_SP, L_SUBFR16k, &exp_ener));
    /* set energy of white noise to energy of excitation */
    tmp = extract_h(Dot_product12_asm(HF, HF, L_SUBFR16k, &exp));
#else
    Syn_filt(Ap, HF, HF, L_SUBFR16k, st->mem_syn_hf, 1);
    /* noise High Pass filtering (1ms of delay) */
    Filt_6k_7k(HF, L_SUBFR16k, st->mem_hf);
    /* filtering of the original signal */
    Filt_6k_7k(HF_SP, L_SUBFR16k, st->mem_hf2);
    /* check the gain difference */
    Scale_sig(HF_SP, L_SUBFR16k, -1);
    ener = extract_h(Dot_product12(HF_SP, HF_SP, L_SUBFR16k, &exp_ener));
    /* set energy of white noise to energy of excitation */
    tmp = extract_h(Dot_product12(HF, HF, L_SUBFR16k, &exp));
#endif

    if (tmp > ener)
    {
        tmp = (tmp >> 1);                 /* Be sure tmp < ener */
        exp = (exp + 1);
    }
    L_tmp = L_deposit_h(div_s(tmp, ener)); /* result is normalized */
    exp = vo_sub(exp, exp_ener);
    Isqrt_n(&L_tmp, &exp);
    L_tmp = L_shl(L_tmp, exp);             /* L_tmp, L_tmp in Q31 */
    HP_calc_gain = extract_h(L_tmp);       /* tmp = sqrt(ener_input/ener_hf) */

    /* st->gain_alpha *= st->dtx_encSt->dtxHangoverCount/7 */
    L_tmp = (vo_L_mult(st->dtx_encSt->dtxHangoverCount, 4681) << 15);
    st->gain_alpha = vo_mult(st->gain_alpha, extract_h(L_tmp));

    if(st->dtx_encSt->dtxHangoverCount > 6)
        st->gain_alpha = 32767;
    HP_est_gain = HP_est_gain >> 1;     /* From Q15 to Q14 */
    HP_corr_gain = add1(vo_mult(HP_calc_gain, st->gain_alpha), vo_mult((32767 - st->gain_alpha), HP_est_gain));

    /* Quantise the correction gain */
    dist_min = 32767;
    for (i = 0; i < 16; i++)
    {
        dist = vo_mult((HP_corr_gain - HP_gain[i]), (HP_corr_gain - HP_gain[i]));
        if (dist_min > dist)
        {
            dist_min = dist;
            HP_gain_ind = i;
        }
    }
    HP_corr_gain = HP_gain[HP_gain_ind];
    /* return the quantised gain index when using the highest mode, otherwise zero */
    return (HP_gain_ind);
}

/*************************************************
*
* Breif: Codec main function
*
**************************************************/

int AMR_Enc_Encode(HAMRENC hCodec)
{
    Word32 i;
    Coder_State *gData = (Coder_State*)hCodec;
    Word16 *signal;
    Word16 packed_size = 0;
    Word16 prms[NB_BITS_MAX];
    Word16 coding_mode = 0, nb_bits, allow_dtx, mode, reset_flag;
    mode = gData->mode;
    coding_mode = gData->mode;
    nb_bits = nb_of_bits[mode];
    signal = (Word16 *)gData->inputStream;
    allow_dtx = gData->allow_dtx;

    /* check for homing frame */
    reset_flag = encoder_homing_frame_test(signal);

    for (i = 0; i < L_FRAME16k; i++)   /* Delete the 2 LSBs (14-bit input) */
    {
        *(signal + i) = (Word16) (*(signal + i) & 0xfffC);
    }

    coder(&coding_mode, signal, prms, &nb_bits, gData, allow_dtx);
    packed_size = PackBits(prms, coding_mode, mode, gData);
    if (reset_flag != 0)
    {
        Reset_encoder(gData, 1);
    }
    return packed_size;
}

/***************************************************************************
*
*Brief: Codec API function --- Initialize the codec and return a codec handle
*
***************************************************************************/

VO_U32 VO_API voAMRWB_Init(VO_HANDLE * phCodec,                   /* o: the audio codec handle */
                           VO_AUDIO_CODINGTYPE vType,             /* i: Codec Type ID */
                           VO_CODEC_INIT_USERDATA * pUserData     /* i: init Parameters */
                           )
{
    Coder_State *st;
    FrameStream *stream;
#ifdef USE_DEAULT_MEM
    VO_MEM_OPERATOR voMemoprator;
#endif
    VO_MEM_OPERATOR *pMemOP;
        UNUSED(vType);

    int interMem = 0;

    if(pUserData == NULL || pUserData->memflag != VO_IMF_USERMEMOPERATOR || pUserData->memData == NULL )
    {
#ifdef USE_DEAULT_MEM
        voMemoprator.Alloc = cmnMemAlloc;
        voMemoprator.Copy = cmnMemCopy;
        voMemoprator.Free = cmnMemFree;
        voMemoprator.Set = cmnMemSet;
        voMemoprator.Check = cmnMemCheck;
        interMem = 1;
        pMemOP = &voMemoprator;
#else
        *phCodec = NULL;
        return VO_ERR_INVALID_ARG;
#endif
    }
    else
    {
        pMemOP = (VO_MEM_OPERATOR *)pUserData->memData;
    }
    /*-------------------------------------------------------------------------*
     * Memory allocation for coder state.                                      *
     *-------------------------------------------------------------------------*/
    if ((st = (Coder_State *)mem_malloc(pMemOP, sizeof(Coder_State), 32, VO_INDEX_ENC_AMRWB)) == NULL)
    {
        return VO_ERR_OUTOF_MEMORY;
    }

    st->vadSt = NULL;
    st->dtx_encSt = NULL;
    st->sid_update_counter = 3;
    st->sid_handover_debt = 0;
    st->prev_ft = TX_SPEECH;
    st->inputStream = NULL;
    st->inputSize = 0;

    /* Default setting */
    st->mode = VOAMRWB_MD2385;                        /* bit rate 23.85kbps */
    st->frameType = VOAMRWB_RFC3267;                  /* frame type: RFC3267 */
    st->allow_dtx = 0;                                /* disable DTX mode */

    st->outputStream = NULL;
    st->outputSize = 0;

    st->stream = (FrameStream *)mem_malloc(pMemOP, sizeof(FrameStream), 32, VO_INDEX_ENC_AMRWB);
    if(st->stream == NULL)
        return VO_ERR_OUTOF_MEMORY;

    st->stream->frame_ptr = (unsigned char *)mem_malloc(pMemOP, Frame_Maxsize, 32, VO_INDEX_ENC_AMRWB);
    if(st->stream->frame_ptr == NULL)
        return  VO_ERR_OUTOF_MEMORY;

    stream = st->stream;
    voAWB_InitFrameBuffer(stream);

    wb_vad_init(&(st->vadSt), pMemOP);
    dtx_enc_init(&(st->dtx_encSt), isf_init, pMemOP);

    Reset_encoder((void *) st, 1);

    if(interMem)
    {
        st->voMemoprator.Alloc = cmnMemAlloc;
        st->voMemoprator.Copy = cmnMemCopy;
        st->voMemoprator.Free = cmnMemFree;
        st->voMemoprator.Set = cmnMemSet;
        st->voMemoprator.Check = cmnMemCheck;
        pMemOP = &st->voMemoprator;
    }

    st->pvoMemop = pMemOP;

    *phCodec = (void *) st;

    return VO_ERR_NONE;
}

/**********************************************************************************
*
* Brief: Codec API function: Input PCM data
*
***********************************************************************************/

VO_U32 VO_API voAMRWB_SetInputData(
        VO_HANDLE hCodec,                   /* i/o: The codec handle which was created by Init function */
        VO_CODECBUFFER * pInput             /*   i: The input buffer parameter  */
        )
{
    Coder_State  *gData;
    FrameStream  *stream;

    if(NULL == hCodec)
    {
        return VO_ERR_INVALID_ARG;
    }

    gData = (Coder_State *)hCodec;
    stream = gData->stream;

    if(NULL == pInput || NULL == pInput->Buffer)
    {
        return VO_ERR_INVALID_ARG;
    }

    stream->set_ptr    = pInput->Buffer;
    stream->set_len    = pInput->Length;
    stream->frame_ptr  = stream->frame_ptr_bk;
    stream->used_len   = 0;

    return VO_ERR_NONE;
}

/**************************************************************************************
*
* Brief: Codec API function: Get the compression audio data frame by frame
*
***************************************************************************************/

VO_U32 VO_API voAMRWB_GetOutputData(
        VO_HANDLE hCodec,                    /* i: The Codec Handle which was created by Init function*/
        VO_CODECBUFFER * pOutput,            /* o: The output audio data */
        VO_AUDIO_OUTPUTINFO * pAudioFormat   /* o: The encoder module filled audio format and used the input size*/
        )
{
    Coder_State* gData = (Coder_State*)hCodec;
    VO_MEM_OPERATOR  *pMemOP;
    FrameStream  *stream = (FrameStream *)gData->stream;
    pMemOP = (VO_MEM_OPERATOR  *)gData->pvoMemop;

    if(stream->framebuffer_len  < Frame_MaxByte)         /* check the work buffer len */
    {
        stream->frame_storelen = stream->framebuffer_len;
        if(stream->frame_storelen)
        {
            pMemOP->Copy(VO_INDEX_ENC_AMRWB, stream->frame_ptr_bk , stream->frame_ptr , stream->frame_storelen);
        }
        if(stream->set_len > 0)
        {
            voAWB_UpdateFrameBuffer(stream, pMemOP);
        }
        if(stream->framebuffer_len < Frame_MaxByte)
        {
            if(pAudioFormat)
                pAudioFormat->InputUsed = stream->used_len;
            return VO_ERR_INPUT_BUFFER_SMALL;
        }
    }

    gData->inputStream = stream->frame_ptr;
    gData->outputStream = (unsigned short*)pOutput->Buffer;

    gData->outputSize = AMR_Enc_Encode(gData);         /* encoder main function */

    pOutput->Length = gData->outputSize;               /* get the output buffer length */
    stream->frame_ptr += 640;                          /* update the work buffer ptr */
    stream->framebuffer_len  -= 640;

    if(pAudioFormat)                                   /* return output audio information */
    {
        pAudioFormat->Format.Channels = 1;
        pAudioFormat->Format.SampleRate = 8000;
        pAudioFormat->Format.SampleBits = 16;
        pAudioFormat->InputUsed = stream->used_len;
    }
    return VO_ERR_NONE;
}

/*************************************************************************
*
* Brief: Codec API function---set the data by specified parameter ID
*
*************************************************************************/


VO_U32 VO_API voAMRWB_SetParam(
        VO_HANDLE hCodec,   /* i/o: The Codec Handle which was created by Init function */
        VO_S32 uParamID,    /*   i: The param ID */
        VO_PTR pData        /*   i: The param value depend on the ID */
        )
{
    Coder_State* gData = (Coder_State*)hCodec;
    FrameStream *stream = (FrameStream *)(gData->stream);
    int *lValue = (int*)pData;

    switch(uParamID)
    {
        /* setting AMR-WB frame type*/
        case VO_PID_AMRWB_FRAMETYPE:
            if(*lValue < VOAMRWB_DEFAULT || *lValue > VOAMRWB_RFC3267)
                return VO_ERR_WRONG_PARAM_ID;
            gData->frameType = *lValue;
            break;
        /* setting AMR-WB bit rate */
        case VO_PID_AMRWB_MODE:
            {
                if(*lValue < VOAMRWB_MD66 || *lValue > VOAMRWB_MD2385)
                    return VO_ERR_WRONG_PARAM_ID;
                gData->mode = *lValue;
            }
            break;
        /* enable or disable DTX mode */
        case VO_PID_AMRWB_DTX:
            gData->allow_dtx = (Word16)(*lValue);
            break;

        case VO_PID_COMMON_HEADDATA:
            break;
        /* flush the work buffer */
        case VO_PID_COMMON_FLUSH:
            stream->set_ptr = NULL;
            stream->frame_storelen = 0;
            stream->framebuffer_len = 0;
            stream->set_len = 0;
            break;

        default:
            return VO_ERR_WRONG_PARAM_ID;
    }
    return VO_ERR_NONE;
}

/**************************************************************************
*
*Brief: Codec API function---Get the data by specified parameter ID
*
***************************************************************************/

VO_U32 VO_API voAMRWB_GetParam(
        VO_HANDLE hCodec,      /* i: The Codec Handle which was created by Init function */
        VO_S32 uParamID,       /* i: The param ID */
        VO_PTR pData           /* o: The param value depend on the ID */
        )
{
    int    temp;
    Coder_State* gData = (Coder_State*)hCodec;

    if (gData==NULL)
        return VO_ERR_INVALID_ARG;
    switch(uParamID)
    {
        /* output audio format */
        case VO_PID_AMRWB_FORMAT:
            {
                VO_AUDIO_FORMAT* fmt = (VO_AUDIO_FORMAT*)pData;
                fmt->Channels   = 1;
                fmt->SampleRate = 16000;
                fmt->SampleBits = 16;
                break;
            }
        /* output audio channel number */
        case VO_PID_AMRWB_CHANNELS:
            temp = 1;
            pData = (void *)(&temp);
            break;
        /* output audio sample rate */
        case VO_PID_AMRWB_SAMPLERATE:
            temp = 16000;
            pData = (void *)(&temp);
            break;
        /* output audio frame type */
        case VO_PID_AMRWB_FRAMETYPE:
            temp = gData->frameType;
            pData = (void *)(&temp);
            break;
        /* output audio bit rate */
        case VO_PID_AMRWB_MODE:
            temp = gData->mode;
            pData = (void *)(&temp);
            break;
        default:
            return VO_ERR_WRONG_PARAM_ID;
    }

    return VO_ERR_NONE;
}

/***********************************************************************************
*
* Brief: Codec API function---Release the codec after all encoder operations are done
*
*************************************************************************************/

VO_U32 VO_API voAMRWB_Uninit(VO_HANDLE hCodec           /* i/o: Codec handle pointer */
                             )
{
    Coder_State* gData = (Coder_State*)hCodec;
    VO_MEM_OPERATOR *pMemOP;
    pMemOP = gData->pvoMemop;

    if(hCodec)
    {
        if(gData->stream)
        {
            if(gData->stream->frame_ptr_bk)
            {
                mem_free(pMemOP, gData->stream->frame_ptr_bk, VO_INDEX_ENC_AMRWB);
                gData->stream->frame_ptr_bk = NULL;
            }
            mem_free(pMemOP, gData->stream, VO_INDEX_ENC_AMRWB);
            gData->stream = NULL;
        }
        wb_vad_exit(&(((Coder_State *) gData)->vadSt), pMemOP);
        dtx_enc_exit(&(((Coder_State *) gData)->dtx_encSt), pMemOP);

        mem_free(pMemOP, hCodec, VO_INDEX_ENC_AMRWB);
        hCodec = NULL;
    }

    return VO_ERR_NONE;
}

/********************************************************************************
*
* Brief: voGetAMRWBEncAPI gets the API handle of the codec
*
********************************************************************************/

VO_S32 VO_API voGetAMRWBEncAPI(
                               VO_AUDIO_CODECAPI * pEncHandle      /* i/o: Codec handle pointer */
                               )
{
    if(NULL == pEncHandle)
        return VO_ERR_INVALID_ARG;
    pEncHandle->Init = voAMRWB_Init;
    pEncHandle->SetInputData = voAMRWB_SetInputData;
    pEncHandle->GetOutputData = voAMRWB_GetOutputData;
    pEncHandle->SetParam = voAMRWB_SetParam;
    pEncHandle->GetParam = voAMRWB_GetParam;
    pEncHandle->Uninit = voAMRWB_Uninit;

    return VO_ERR_NONE;
}

#ifdef __cplusplus
}
#endif