/*====================================================================================
    EVS Codec 3GPP TS26.443 Jun 30, 2015. Version CR 26.443-0006
  ====================================================================================*/

#include <math.h>
#include "options.h"
#include "cnst.h"
#include "rom_enc.h"
#include "rom_com.h"
#include "prot.h"

/*---------------------------------------------------------------------*
 * Local constants
 *---------------------------------------------------------------------*/

#define MAX_DELTA_CNG             1

/*---------------------------------------------------------------------*
 * Local functions
 *---------------------------------------------------------------------*/

static short shb_DTX( Encoder_State *st, const float *shb_speech, const float *syn_12k8_16k );

static void shb_CNG_encod( Encoder_State *st, const short update
                         );

/*---------------------------------------------------------------------*
 * CNG_enc()
 *
 * Confort noise generation for the coder
 *---------------------------------------------------------------------*/

void CNG_enc(
    Encoder_State *st,             /* i/o: State structure                                 */
    const short L_frame,         /* i  : length of the frame                             */
    float Aq[],            /* o  : LP coefficients                                 */
    const float *speech,         /* i  : pointer to current frame input speech buffer    */
    float enr,             /* i  : residual energy from Levinson-Durbin            */
    float *lsp_new,        /* i/o: current frame ISPs                              */
    float *lsf_new,        /* i/o: current frame ISFs                              */
    short *allow_cn_step,  /* o  : allow CN step                                   */
    short burst_ho_cnt,    /* i  : hangover frames at end of speech burst          */
    float *q_env,
    short *sid_bw,
    float *exc_mem2
)
{
    short enr_index, i;
    float step, res[L_FRAME16k];
    short maxl, num_bits;
    short j, k, ptr;
    short m1;
    float weights;
    float sp_enr;
    short m = 0;
    float tmp[HO_HIST_SIZE*M];
    short ll, s_ptr;
    float att=1.0f;
    float lsf_tmp[M];
    float C[M];
    float max[2];
    short max_idx[2];
    float ftmp;
    float lsp_tmp[M];
    float dev;
    float max_dev;
    float dist;
    short max_idx1[2]= {0,0};
    float fft_io[L_FRAME16k];
    float *ptR,*ptI;
    float enr1=0;
    float env[NUM_ENV_CNG];
    float min1;
    short min1_idx;
    float d;
    float res1[L_FRAME16k];
    float tmp_env[HO_HIST_SIZE*NUM_ENV_CNG];
    short force_cn_step=0;

    /* calculate input energy */
    sp_enr = (float) log10( sum2_f( speech, L_frame )/L_frame + 0.1f )/ (float)log10(2.0f);

    if (sp_enr < 0.0f)
    {
        sp_enr = 0.0f;
    }

    if ( st->first_CNG == 0 || st->old_enr_index < 0 )
    {
        st->lp_sp_enr = sp_enr;
    }
    else
    {
        if ( st->last_core_brate > SID_2k40 && burst_ho_cnt > 0 && st->lp_sp_enr < 6.0f && (sp_enr - st->lp_sp_enr) > 4.0f && sp_enr > 6.0f )
        {
            st->lp_sp_enr = sp_enr;
            force_cn_step = 1;
        }
        else
        {
            st->lp_sp_enr  = 0.1f * sp_enr  + 0.9f * st->lp_sp_enr;
        }
    }

    /* update the pointer to circular buffer of old LSP vectors */
    if( ++(st->cng_hist_ptr) == DTX_HIST_SIZE )
    {
        st->cng_hist_ptr = 0;
    }

    /* update the circular buffer of old LSP vectors with the new LSP vector */
    mvr2r( lsp_new, &(st->cng_lsp_hist[(st->cng_hist_ptr)*M]), M );

    /*-----------------------------------------------------------------*
     * Find CNG spectral envelope
     * Find LSP median
     *-----------------------------------------------------------------*/

    if( (st->core_brate == SID_2k40 || st->core_brate == SID_1k75) && st->cng_cnt >= (st->cng_hist_size-1) )
    {
        set_f( max, 0.0f, 2 );
        set_s( max_idx, 0, 2 );

        for( i=0; i<st->cng_hist_size; i++ )
        {
            if (st->L_frame == L_FRAME )
            {
                lsp2lsf( &st->cng_lsp_hist[i*M], lsf_tmp, M, INT_FS_12k8 );
                ftmp = 6400.0f / (M+1);
                C[i] = (6400.0f - lsf_tmp[M-1] - ftmp) * (6400.0f - lsf_tmp[M-1] - ftmp);
            }
            else
            {
                lsp2lsf( &st->cng_lsp_hist[i*M], lsf_tmp, M, INT_FS_16k );
                ftmp = 8000.0f / (M+1);
                C[i] = (8000.0f - lsf_tmp[M-1] - ftmp) * (8000.0f - lsf_tmp[M-1] - ftmp);
            }

            C[i] += (lsf_tmp[0] - ftmp) * (lsf_tmp[0] - ftmp);

            for ( j=0; j<M-1; j++ )
            {
                C[i] += (lsf_tmp[j+1] - lsf_tmp[j] - ftmp) * (lsf_tmp[j+1] - lsf_tmp[j] - ftmp);
            }

            C[i] *= 0.0588235f; /* 1/M+1 */

            if ( C[i] > max[0] )
            {
                max[1] = max[0];
                max_idx[1] = max_idx[0];
                max[0] = C[i];
                max_idx[0] = i;
            }
            else if ( C[i] > max[1] )
            {
                max[1] = C[i];
                max_idx[1] = i;
            }
        }

        for ( i=0; i<M; i++ )
        {
            lsp_new[i] = 0.0f;
            for ( j=0; j<st->cng_hist_size; j++ )
            {
                lsp_new[i] += st->cng_lsp_hist[j*M+i];
            }

            lsp_new[i] -= (st->cng_lsp_hist[max_idx[0]*M+i] + st->cng_lsp_hist[max_idx[1]*M+i]);
            lsp_new[i] /= (float)(st->cng_hist_size - 2);
        }
        max_idx1[0] = max_idx[0];
        max_idx1[1] = max_idx[1];
    }

    /*-----------------------------------------------------------------*
     * Quantize CNG spectral envelope (only in SID frame)
     * Quantize the LSF vector
     *-----------------------------------------------------------------*/
    *allow_cn_step = ((st->cng_cnt == 0) &&
                      (st->lp_sp_enr > 6.0f) &&
                      ((st->lp_sp_enr + 4.0f) < sp_enr) &&
                      (st->first_CNG != 0 ) &&
                      (st->old_enr_index >= 0) &&
                      (st->last_core_brate > SID_2k40)) ||
                     force_cn_step;

    if( st->core_brate == SID_2k40 || st->core_brate == SID_1k75 )
    {
        /* LSF quantization */
        if ( st->Opt_AMR_WB )
        {
            isf_enc_amr_wb( st, lsf_new, lsp_new, 0, 0, 0 );
        }
        else
        {
            lsf_enc( st, L_frame, INACTIVE, lsf_new, lsp_new, 0, 0, 0, 100 );
        }

        /* Reset CNG history if CNG frame length is changed */
        if ( st->bwidth == WB && st->first_CNG && st->L_frame != st->last_CNG_L_frame )
        {
            st->ho_hist_size = 0;
        }
    }
    else
    {
        /* Use old LSP vector */
        mvr2r( st->lsp_old, lsp_new, M );
        mvr2r( st->lsf_old, lsf_new, M );
    }

    /* Initialize the CNG spectral envelope in case of the very first CNG frame */
    if( st->first_CNG == 0 )
    {
        mvr2r( st->lsp_old, st->lspCNG, M );
    }

    /*---------------------------------------------------------------------*
     * CNG spectral envelope update
     * Find A(z) coefficients
     *---------------------------------------------------------------------*/

    if( st->last_core_brate == FRAME_NO_DATA || st->last_core_brate == SID_1k75 || st->last_core_brate == SID_2k40 )
    {
        /* Reset hangover counter if not first SID period */
        if( st->core_brate > FRAME_NO_DATA )
        {
            st->num_ho = 0;
        }
        /* Update LSPs if last SID energy not outlier or insufficient number of hangover frames */
        if( st->num_ho < 3 || st->Enew < 1.5f * st->lp_ener )
        {
            for( i=0; i<M; i++ )
            {
                /* AR low-pass filter  */
                st->lspCNG[i] = CNG_ISF_FACT * st->lspCNG[i] + (1-CNG_ISF_FACT) * lsp_new[i];
            }
        }
    }
    else
    {
        /* Update CNG_mode if allowed */
        if( ( st->Opt_AMR_WB || st->bwidth == WB ) && ( !st->first_CNG || st->act_cnt2 >= MIN_ACT_CNG_UPD ) )
        {
            if( st->last_active_brate > ACELP_16k40 )
            {
                st->CNG_mode = -1;
            }
            else if( st->last_active_brate > ACELP_13k20 )
            {
                st->CNG_mode = 4;
            }
            else if( st->last_active_brate > ACELP_9k60 )
            {
                st->CNG_mode = 3;
            }
            else if( st->last_active_brate > ACELP_8k00 )
            {
                st->CNG_mode = 2;
            }
            else if( st->last_active_brate > ACELP_7k20 )
            {
                st->CNG_mode = 1;
            }
            else
            {
                st->CNG_mode = 0;
            }
        }

        /* If first SID after active burst update LSF history from circ buffer */
        st->act_cnt = 0;
        s_ptr = st->ho_circ_ptr-burst_ho_cnt+1;
        if( s_ptr < 0 )
        {
            s_ptr += st->ho_circ_size;
        }

        for( ll = burst_ho_cnt; ll > 0; ll-- )
        {
            if( ++(st->ho_hist_ptr) == HO_HIST_SIZE )
            {
                st->ho_hist_ptr = 0;
            }
            /* Conversion between 12.8k and 16k LSPs */
            if( L_frame == L_FRAME && st->ho_16k_lsp[s_ptr] == 1 )
            {
                /* Conversion from 16k LPSs to 12k8 */
                lsp_convert_poly( &(st->ho_lsp_circ[s_ptr*M]), L_frame, 0 );
            }
            else if ( L_frame == L_FRAME16k && st->ho_16k_lsp[s_ptr] == 0 )
            {
                /* 16k LSPs already converted and stored, just copy to the other buffer */
                mvr2r(&(st->ho_lsp_circ2[s_ptr*M]), &(st->ho_lsp_circ[s_ptr*M]), M );
            }

            /* update circular buffers */
            mvr2r(&(st->ho_lsp_circ[s_ptr*M]), &(st->ho_lsp_hist[st->ho_hist_ptr*M]), M );
            mvr2r(&(st->ho_ener_circ[s_ptr]), &(st->ho_ener_hist[st->ho_hist_ptr]), 1 );
            st->ho_sid_bw = ( st->ho_sid_bw & 0x3fffffffL ) << 1;
            mvr2r(&(st->ho_env_circ[s_ptr*NUM_ENV_CNG]), &(st->ho_env_hist[st->ho_hist_ptr*NUM_ENV_CNG]), NUM_ENV_CNG );

            st->ho_hist_size++;
            if (st->ho_hist_size > HO_HIST_SIZE)
            {
                st->ho_hist_size = HO_HIST_SIZE;
            }

            s_ptr++;

            if( s_ptr == st->ho_circ_size )
            {
                s_ptr = 0;
            }
        }
        if ( burst_ho_cnt > 0)
        {
            *allow_cn_step |= ( st->ho_ener_hist[st->ho_hist_ptr] > 4.0f * st->lp_ener );
        }

        if ( !*allow_cn_step && st->ho_hist_size > 0 )
        {
            ptr = st->ho_hist_ptr;
            mvr2r( &(st->ho_lsp_hist[ptr*M]), tmp, M );
            m1 = 0;
            if( (st->ho_sid_bw & 0x1L) == 0 )
            {
                mvr2r( &st->ho_env_hist[ptr*NUM_ENV_CNG], tmp_env, NUM_ENV_CNG );
                m1 = 1;
            }
            enr = W_DTX_HO[0] * st->ho_ener_hist[ptr];
            weights = W_DTX_HO[0];
            m = 1;
            for( k=1; k<st->ho_hist_size; k++ )
            {
                ptr--;
                if( ptr < 0 )
                {
                    ptr = HO_HIST_SIZE - 1;
                }

                if ( st->ho_ener_hist[ptr] <  st->ho_ener_hist[st->ho_hist_ptr] * BUF_H_NRG &&
                        st->ho_ener_hist[ptr] > st->ho_ener_hist[st->ho_hist_ptr] * BUF_L_NRG )
                {
                    enr += W_DTX_HO[k] * st->ho_ener_hist[ptr];
                    weights += W_DTX_HO[k];
                    mvr2r( &st->ho_lsp_hist[ptr*M], &tmp[m*M], M );
                    if( (st->ho_sid_bw & (0x1L << k)) == 0 )
                    {
                        mvr2r( &st->ho_env_hist[ptr*NUM_ENV_CNG], &tmp_env[m1*NUM_ENV_CNG], NUM_ENV_CNG );
                        m1++;
                    }
                    m++;
                }
            }

            enr /= weights;
            st->lp_ener = enr;

            set_f( max, 0.0f, 2 );
            set_s( max_idx, 0, 2 );

            for( i=0; i<m; i++ )
            {
                if (st->L_frame == L_FRAME )
                {
                    lsp2lsf( &tmp[i*M], lsf_tmp, M, INT_FS_12k8 );
                    ftmp = 6400.0f / (M+1);
                    C[i] = (6400.0f - lsf_tmp[M-1] - ftmp) * (6400.0f - lsf_tmp[M-1] - ftmp);
                }
                else
                {
                    lsp2lsf( &tmp[i*M], lsf_tmp, M, INT_FS_16k );
                    ftmp = 8000.0f / (M+1);
                    C[i] = (8000.0f - lsf_tmp[M-1] - ftmp) * (8000.0f - lsf_tmp[M-1] - ftmp);
                }

                C[i] += (lsf_tmp[0] - ftmp) * (lsf_tmp[0] - ftmp);

                for ( j=0; j<M-1; j++ )
                {
                    C[i] += (lsf_tmp[j+1] - lsf_tmp[j] - ftmp) * (lsf_tmp[j+1] - lsf_tmp[j] - ftmp);
                }

                C[i] *= 0.0588235f; /* 1/M+1 */

                if ( C[i] > max[0] )
                {
                    max[1] = max[0];
                    max_idx[1] = max_idx[0];
                    max[0] = C[i];
                    max_idx[0] = i;
                }
                else if ( C[i] > max[1] )
                {
                    max[1] = C[i];
                    max_idx[1] = i;
                }
            }

            if ( m == 1 )
            {
                mvr2r(tmp, lsp_tmp, M);
            }
            else if ( m < 4 )
            {
                for ( i=0; i<M; i++ )
                {
                    lsp_tmp[i] = 0.0f;
                    for ( j=0; j<m; j++ )
                    {
                        lsp_tmp[i] += tmp[j*M+i];
                    }

                    lsp_tmp[i] -= tmp[max_idx[0]*M+i];
                    lsp_tmp[i] /= (float)(m - 1);
                }
            }
            else
            {
                for ( i=0; i<M; i++ )
                {
                    lsp_tmp[i] = 0.0f;
                    for ( j=0; j<m; j++ )
                    {
                        lsp_tmp[i] += tmp[j*M+i];
                    }

                    lsp_tmp[i] -= (tmp[max_idx[0]*M+i] + tmp[max_idx[1]*M+i]);
                    lsp_tmp[i] /= (float)(m - 2);
                }
            }

            dist = 0.0f;
            max_dev = 0.0f;
            for ( i=0; i<M; i++ )
            {
                dev = (float)fabs(lsp_tmp[i] - lsp_new[i]);
                dist += dev;
                if ( dev > max_dev )
                {
                    max_dev = dev;
                }
            }

            if ( dist > 0.4f || max_dev > 0.1f )
            {
                for( i=0; i<M; i++ )
                {
                    st->lspCNG[i] = lsp_tmp[i];
                }
            }
            else
            {
                for( i=0; i<M; i++ )
                {
                    /* AR low-pass filter  */
                    st->lspCNG[i] = 0.8f * lsp_tmp[i] + (1-0.8f) * lsp_new[i];
                }
            }
            if( m1 > 0 )
            {
                for ( i=0; i<NUM_ENV_CNG; i++ )
                {
                    env[i] = 0;
                    for ( j=0; j<m1; j++ )
                    {
                        env[i] += tmp_env[j*NUM_ENV_CNG+i];
                    }

                    env[i] /= (float)m1;
                    env[i] = env[i] - 2*st->lp_ener;
                }
                mvr2r(env, st->lp_env, NUM_ENV_CNG);
            }
        }
        else
        {
            mvr2r( lsp_new, st->lspCNG, M );  /* use newly analyzed parameters */
        }
    }

    if ( st->Opt_AMR_WB )
    {
        isp2a( st->lspCNG, Aq, M );
    }
    else
    {
        lsp2a_stab( st->lspCNG, Aq, M );
    }

    for( i=1; i<L_frame/L_SUBFR; i++ )
    {
        mvr2r( Aq, &Aq[i*(M+1)], M+1 );
    }

    /*-----------------------------------------------------------------*
     * Find residual signal
     * Calculate residual signal energy per sample
     *-----------------------------------------------------------------*/

    /* calculate the residual signal */
    residu( Aq, M, speech, res, L_frame );

    mvr2r(res, res1, L_frame);
    if( st->bwidth != NB )
    {
        if( st->bwidth == WB && st->CNG_mode >= 0 )
        {
            ftmp = HO_ATT[st->CNG_mode];
        }
        else
        {
            ftmp = 0.6f;
        }

        att = ftmp/6.0f;
        att = 1.0f/(1 + att * 8);

        if ( att < ftmp )
        {
            att = ftmp;
        }

        for( i = 0; i < st->L_frame; i++ )
        {
            res1[i] *= att;
        }
    }

    /* calculate the spectrum of residual signal */
    mvr2r(res1, fft_io, st->L_frame);

    if ( st->L_frame == L_FRAME16k )
    {
        modify_Fs( fft_io, L_FRAME16k, 16000, fft_io, 12800, exc_mem2, 0 );
    }

    fft_rel(fft_io, L_FFT, LOG2_L_FFT);
    ptR = &fft_io[1];
    ptI = &fft_io[L_FFT-1];
    for ( i=0; i<NUM_ENV_CNG; i++ )
    {
        env[i] = 2.0f*(*ptR **ptR + *ptI **ptI)/L_FFT;
        ptR++;
        ptI--;
    }

    mvr2r( env, &(st->cng_res_env[(st->cng_hist_ptr)*NUM_ENV_CNG]), NUM_ENV_CNG );
    /* calculate the residual signal energy */
    enr = dotp( res, res, L_frame ) / L_frame;

    /* convert log2 of residual signal energy */
    enr = (float)log10( enr + 0.1f ) / (float)log10( 2.0f );

    /* update the circular buffer of old energies */
    st->cng_ener_hist[st->cng_hist_ptr] = enr;

    /*-----------------------------------------------------------------*
     * Quantize residual signal energy (only in SID frame)
     *-----------------------------------------------------------------*/

    if( st->core_brate == SID_2k40 || st->core_brate == SID_1k75 )
    {
        if( st->cng_cnt >= st->cng_hist_size - 1 )
        {
            /* average the envelope except outliers */
            for ( i=0; i<NUM_ENV_CNG; i++ )
            {
                for ( j=0; j<st->cng_hist_size; j++ )
                {
                    env[i] += st->cng_res_env[j*NUM_ENV_CNG+i];
                }

                env[i] -= (st->cng_res_env[max_idx1[0]*NUM_ENV_CNG+i] + st->cng_res_env[max_idx1[1]*NUM_ENV_CNG+i]);
                env[i] /= (float)(st->cng_hist_size - 2);
            }
            /* compute average excitation energy */
            enr = 0;
            weights = 0;
            ptr = st->cng_hist_ptr;

            for( k=0; k<st->cng_hist_size; k++ )
            {
                enr += W_HIST[k] * st->cng_ener_hist[ptr--];
                if( ptr < 0 )
                {
                    ptr = DTX_HIST_SIZE - 1;
                }

                weights += W_HIST[k];
            }

            /* normalize the average value */
            enr /= weights;
        }

        /* decrease the energy in case of WB input */
        if( st->bwidth != NB )
        {
            if( st->bwidth == WB )
            {
                if( st->CNG_mode >= 0 )
                {
                    /* Bitrate adapted attenuation */
                    att = ENR_ATT[st->CNG_mode];
                }
                else
                {
                    /* Use least attenuation for higher bitrates */
                    att = ENR_ATT[4];
                }
            }
            else
            {
                att = 1.5f;
            }

            enr -= att;
        }

        /* intialize the energy quantization parameters */
        if( !st->Opt_AMR_WB )
        {
            step = STEP_SID;
            maxl = 127;
            num_bits = 7;
        }
        else
        {
            step = STEP_AMR_WB_SID;
            maxl = 63;
            num_bits = 6;
        }

        /* calculate the energy quantization index */
        enr_index = (short)( (enr + 2.0f) * step );

        /* limit the energy quantization index */
        if( enr_index > maxl )
        {
            enr_index = maxl;
        }

        if( enr_index < 0 )
        {
            enr_index = 0;
        }

        /* allow only slow energy increase */
        if( st->first_CNG && enr_index > st->old_enr_index + MAX_DELTA_CNG )
        {
            if( *allow_cn_step == 1 )
            {
                enr_index = st->old_enr_index + (short) (0.85f*(enr_index - st->old_enr_index)) ;
            }
            else
            {
                enr_index = st->old_enr_index + MAX_DELTA_CNG;
            }
        }
        st->old_enr_index = enr_index;

        push_indice( st, IND_ENERGY, enr_index, num_bits );
        if ( enr_index == 0 )
        {
            enr_index = -5;
        }
        /* find the quatized energy */
        st->Enew = (float)enr_index / step - 2.0f;
        st->Enew = (float)( pow( 2.0f, st->Enew ) );
        if ( st->core_brate == SID_2k40 )
        {
            enr1 = (float)log10( st->Enew*L_frame + 0.1f ) / (float)log10( 2.0f );
            for ( i=0; i<NUM_ENV_CNG; i++ )
            {
                env[i] -= 2 * st->Enew;

                if ( env[i] < 0.0f )
                {
                    env[i] = 0.1f;
                }

                env[i] = (float)log10( env[i] + 0.1f ) / (float)log10( 2.0f );
                env[i] -= att;

                if ( env[i] < 0 )
                {
                    env[i] = 0;
                }

                env[i] = enr1 - env[i];
            }

            /* codebook search */
            min1 = 9999.0f;;
            min1_idx = 0;

            for ( i=0; i<64; i++ )
            {
                d = 0.0f;
                for ( j=0; j<NUM_ENV_CNG; j++ )
                {
                    d += (env[j] - CNG_details_codebook[i][j]) * (env[j] - CNG_details_codebook[i][j]);
                }

                if ( d < min1 )
                {
                    min1 = d;
                    min1_idx = i;
                }
            }
            push_indice( st, IND_CNG_ENV1, min1_idx, 6 );
            /* get quantized res_env_details */
            for ( i=0; i<NUM_ENV_CNG; i++ )
            {
                q_env[i] = CNG_details_codebook[min1_idx][i];
            }
        }
        /* Update hangover memory during CNG */
        if ( !*allow_cn_step && (st->Enew < 1.5f * st->lp_ener) )
        {
            /* update the pointer to circular buffer of old LSP vectors */
            if( ++(st->ho_hist_ptr) == HO_HIST_SIZE )
            {
                st->ho_hist_ptr = 0;
            }

            /* update the circular buffer of old LSP vectors with the new LSP vector */
            mvr2r( lsp_new, &(st->ho_lsp_hist[(st->ho_hist_ptr)*M]), M );

            /* update the hangover energy buffer */
            st->ho_ener_hist[st->ho_hist_ptr] = st->Enew;
            if ( st->core_brate == SID_2k40 )
            {
                for ( i=0; i<NUM_ENV_CNG; i++ )
                {
                    /* get quantized envelope */
                    env[i] = pow(2.0f,(enr1 - q_env[i])) + 2*st->Enew;
                }
                mvr2r( env, &(st->ho_env_hist[(st->ho_hist_ptr)*NUM_ENV_CNG]), NUM_ENV_CNG );
            }
            if(++(st->ho_hist_size) > HO_HIST_SIZE)
            {
                st->ho_hist_size = HO_HIST_SIZE;
            }
        }
    }

    /* dithering bit for AMR-WB IO mode is always set to 0 */
    if( st->core_brate == SID_1k75 )
    {
        push_indice( st, IND_DITHERING, 0, 1 );
    }

    if ( st->core_brate == SID_2k40 )
    {
        push_indice( st, IND_ACELP_16KHZ, st->L_frame == L_FRAME16k ? 1 : 0, 1 );
    }

    if ( st->core_brate == SID_2k40 )
    {
        /*  transmit ho_cnt for use at decoder side as  CNG synthesis assistance   */
        if( st->burst_ho_cnt > (HO_HIST_SIZE-1) )
        {
            push_indice( st, IND_CNG_HO, (HO_HIST_SIZE-1), 3 );  /* send max allowed value , limited to 7 */
        }
        else
        {
            push_indice( st, IND_CNG_HO, st->burst_ho_cnt, 3 );   /* send actual value */
        }
        st->num_ho = m;
        push_indice( st, IND_SID_TYPE, 0, 1 );

        if ( st->input_Fs < 32000 )
        {
            push_indice( st, IND_SID_BW, 0, 1 );
            *sid_bw = 0;
        }
    }

    /*-----------------------------------------------------------------*
     * Updates
     *-----------------------------------------------------------------*/

    /* update the SID frames counter */
    if( st->core_brate == SID_2k40 || st->core_brate == SID_1k75 )
    {
        st->cng_cnt = 0;
        st->cng_hist_ptr = -1;

        /* update frame length memory */
        st->last_CNG_L_frame = st->L_frame;
    }
    else
    {
        st->cng_cnt++;
    }



    return;
}

/*---------------------------------------------------------------------*
 * swb_CNG_enc()
 *
 * SWB DTX/CNG encoding
 *---------------------------------------------------------------------*/

void swb_CNG_enc(
    Encoder_State *st,             /* i/o: State structure                                 */
    const float *shb_speech,     /* i  : SHB target signal (6-14kHz) at 16kHz            */
    const float *syn_12k8_16k    /* i  : ACELP core synthesis at 12.8kHz or 16kHz        */
)
{
    short shb_SID_updt;

    if( st->core_brate == SID_2k40 || st->core_brate == FRAME_NO_DATA )
    {
        if ( st->cng_type == LP_CNG )
        {
            /* decide if SHB SID encoding or not */
            shb_SID_updt = shb_DTX( st, shb_speech, syn_12k8_16k );

            /* SHB CNG encoding */
            shb_CNG_encod( st, shb_SID_updt );
        }
        st->last_vad = 0;
    }
    else
    {
        st->last_vad = 1;
    }

    return;
}

/*---------------------------------------------------------------------*
 * shb_CNG_encod()
 *
 * SID parameters encoding for SHB signal
 *---------------------------------------------------------------------*/

static void shb_CNG_encod(
    Encoder_State *st,             /* i/o: State structure                                 */
    const short update           /* i  : SID update flag                                 */
)
{
    short idx_ener = 0;

    if ( update == 1 )
    {
        /* SHB energy quantization */
        idx_ener = (short)(0.9f * (0.1f*st->mov_shb_cng_ener/(float)log10(2.0f) + 6.0f) + 0.5f );
        if ( st->bwidth < SWB )
        {
            idx_ener = 0;
        }

        if ( idx_ener > 15 )
        {
            idx_ener = 15;
        }
        else if ( idx_ener < 0 )
        {
            idx_ener = 0;
        }

        push_indice( st, IND_SHB_CNG_GAIN, idx_ener, 4 );
        push_indice( st, IND_SID_BW, 1, 1 );
        st->nb_bits_tot = st->nb_bits_tot - st->ind_list[IND_CNG_ENV1].nb_bits;
        st->ind_list[IND_CNG_ENV1].nb_bits = -1;
        push_indice( st, IND_UNUSED, 0, 2 );
        st->ho_sid_bw = ( st->ho_sid_bw & 0x3fffffffL ) << 1;
        st->ho_sid_bw |= 0x1L;
    }
    else if ( st->core_brate == SID_2k40 )
    {
        st->ho_sid_bw = ( st->ho_sid_bw & 0x3fffffffL ) << 1;
        push_indice( st, IND_SID_BW, 0, 1 );
    }


    return;
}

/*---------------------------------------------------------------------*
 * shb_DTX()
 *
 * Decide if encoding SHB SID or not
 *---------------------------------------------------------------------*/

static short shb_DTX(
    Encoder_State *st,             /* i/o: State structure                                 */
    const float *shb_speech,     /* i  : SHB target signal (6-14kHz) at 16kHz            */
    const float *syn_12k8_16k    /* i  : ACELP core synthesis at 12.8kHz or 16kHz        */
)
{
    short i;
    short update;
    float shb_old_speech[(L_LOOK_12k8 + L_SUBFR + L_FRAME) * 5/4];
    float *shb_new_speech;
    float wb_ener;
    float shb_ener;
    float log_wb_ener;
    float log_shb_ener;
    float ftmp;
    short allow_cn_step=0;

    shb_new_speech = shb_old_speech + (L_LOOK_12k8 + L_SUBFR) * 5/4;
    mvr2r( st->old_speech_shb, shb_old_speech, (L_LOOK_12k8 + L_SUBFR) * 5/4 );
    mvr2r( shb_speech, shb_new_speech, L_FRAME16k );
    mvr2r( shb_old_speech + L_FRAME16k, st->old_speech_shb, (L_LOOK_12k8 + L_SUBFR) * 5/4 );

    shb_ener = 0;
    for ( i=0; i<L_FRAME16k; i++ )
    {
        shb_ener += shb_old_speech[i] * shb_old_speech[i];
    }
    shb_ener /= L_FRAME16k;

    wb_ener = sum2_f( syn_12k8_16k, st->L_frame) + 0.001f;
    wb_ener = wb_ener/st->L_frame;

    log_wb_ener = 10 * (float)log10(wb_ener);
    log_shb_ener = 10 * (float)log10(shb_ener) - 6.5f;

    if ( st->first_CNG == 0 )
    {
        st->mov_wb_cng_ener = log_wb_ener;
        st->mov_shb_cng_ener = log_shb_ener;
        st->last_wb_cng_ener = log_wb_ener;
        st->last_shb_cng_ener = log_shb_ener;
    }
    if ( fabs(log_wb_ener - st->mov_wb_cng_ener) > 12.0f )
    {
        allow_cn_step = 1;
    }

    if ( allow_cn_step == 1 )
    {
        st->mov_wb_cng_ener = log_wb_ener;
        st->mov_shb_cng_ener = log_shb_ener;
    }
    else
    {
        ftmp = log_wb_ener - st->mov_wb_cng_ener;

        st->mov_wb_cng_ener += 0.9f * ftmp;

        ftmp = log_shb_ener - st->mov_shb_cng_ener;

        st->mov_shb_cng_ener += 0.25f * ftmp;
    }
    st->shb_NO_DATA_cnt++;

    update = 0;
    if ( st->core_brate == SID_2k40 )
    {
        if ( st->first_CNG == 0 )
        {
            update = 1;
        }
        else if ( st->shb_cng_ini_cnt > 0 )
        {
            st->shb_cng_ini_cnt--;
            update = 1;
        }
        else if ( st->last_vad == 1 )
        {
            update = 1;
        }
        else if ( st->shb_NO_DATA_cnt >= 100 )
        {
            update = 1;
        }
        else if ( fabs((st->mov_wb_cng_ener - st->mov_shb_cng_ener) - (st->last_wb_cng_ener - st->last_shb_cng_ener)) > 3.0f )
        {
            update = 1;
        }
        else if ( (st->bwidth >=SWB && st->last_SID_bwidth < SWB) || (st->bwidth <SWB && st->last_SID_bwidth >= SWB) )
        {
            update = 1;
        }

        st->last_SID_bwidth = st->bwidth;
    }

    if ( update == 1 )
    {
        st->last_wb_cng_ener = st->mov_wb_cng_ener;
        st->last_shb_cng_ener = st->mov_shb_cng_ener;
        st->shb_NO_DATA_cnt = 0;
    }

    return (update);
}