amrwbenc/src/wb_vad.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: wb_vad.c                                                  *
*                                                                      *
*      Description: Voice Activity Detection                           *
*                                                                      *
************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include "cnst.h"
#include "wb_vad.h"
#include "typedef.h"
#include "basic_op.h"
#include "math_op.h"
#include "wb_vad_c.h"
#include "mem_align.h"

/******************************************************************************
*  Calculate Log2 and scale the signal:
*
*    ilog2(Word32 in) = -1024*log10(in * 2^-31)/log10(2), where in = [1, 2^31-1]
*
*  input   output
*  32768   16384
*  1       31744
*
* When input is in the range of [1,2^16], max error is 0.0380%.
*********************************************************************************/

static Word16 ilog2(                       /* return: output value of the log2 */
        Word16 mant                        /* i: value to be converted */
        )
{
    Word16 ex, ex2, res;
    Word32 i, l_temp;

    if (mant <= 0)
    {
        mant = 1;
    }
    ex = norm_s(mant);
    mant = mant << ex;

    for (i = 0; i < 3; i++)
        mant = vo_mult(mant, mant);
    l_temp = vo_L_mult(mant, mant);

    ex2 = norm_l(l_temp);
    mant = extract_h(l_temp << ex2);

    res = (ex + 16) << 10;
    res = add1(res, (ex2 << 6));
    res = vo_sub(add1(res, 127), (mant >> 8));
    return (res);
}

/******************************************************************************
*
*     Function     : filter5
*     Purpose      : Fifth-order half-band lowpass/highpass filter pair with
*                    decimation.
*
*******************************************************************************/

static void filter5(
        Word16 * in0,                         /* i/o : input values; output low-pass part  */
        Word16 * in1,                         /* i/o : input values; output high-pass part */
        Word16 data[]                         /* i/o : filter memory                       */
        )
{
    Word16 temp0, temp1, temp2;

    temp0 = vo_sub(*in0, vo_mult(COEFF5_1, data[0]));
    temp1 = add1(data[0], vo_mult(COEFF5_1, temp0));
    data[0] = temp0;

    temp0 = vo_sub(*in1, vo_mult(COEFF5_2, data[1]));
    temp2 = add1(data[1], vo_mult(COEFF5_2, temp0));
    data[1] = temp0;

    *in0 = extract_h((vo_L_add(temp1, temp2) << 15));
    *in1 = extract_h((vo_L_sub(temp1, temp2) << 15));
}

/******************************************************************************
*
*     Function     : filter3
*     Purpose      : Third-order half-band lowpass/highpass filter pair with
*                    decimation.
*
*******************************************************************************/

static void filter3(
        Word16 * in0,                         /* i/o : input values; output low-pass part  */
        Word16 * in1,                         /* i/o : input values; output high-pass part */
        Word16 * data                         /* i/o : filter memory                       */
        )
{
    Word16 temp1, temp2;

    temp1 = vo_sub(*in1, vo_mult(COEFF3, *data));
    temp2 = add1(*data, vo_mult(COEFF3, temp1));
    *data = temp1;

    *in1 = extract_h((vo_L_sub(*in0, temp2) << 15));
    *in0 = extract_h((vo_L_add(*in0, temp2) << 15));
}

/******************************************************************************
*
*     Function   : level_calculation
*     Purpose    : Calculate signal level in a sub-band. Level is calculated
*                  by summing absolute values of the input data.
*
*                  Signal level calculated from of the end of the frame
*                  (data[count1 - count2]) is stored to (*sub_level)
*                  and added to the level of the next frame.
*
******************************************************************************/

static Word16 level_calculation(                      /* return: signal level */
        Word16 data[],                        /* i   : signal buffer                                    */
        Word16 * sub_level,                   /* i   : level calculated at the end of the previous frame*/
                                              /* o   : level of signal calculated from the last         */
                                              /*       (count2 - count1) samples                        */
        Word16 count1,                        /* i   : number of samples to be counted                  */
        Word16 count2,                        /* i   : number of samples to be counted                  */
        Word16 ind_m,                         /* i   : step size for the index of the data buffer       */
        Word16 ind_a,                         /* i   : starting index of the data buffer                */
        Word16 scale                          /* i   : scaling for the level calculation                */
        )
{
    Word32 i, l_temp1, l_temp2;
    Word16 level;

    l_temp1 = 0L;
    for (i = count1; i < count2; i++)
    {
        l_temp1 += (abs_s(data[ind_m * i + ind_a])<<1);
    }

    l_temp2 = vo_L_add(l_temp1, L_shl(*sub_level, 16 - scale));
    *sub_level = extract_h(L_shl(l_temp1, scale));

    for (i = 0; i < count1; i++)
    {
        l_temp2 += (abs_s(data[ind_m * i + ind_a])<<1);
    }
    level = extract_h(L_shl2(l_temp2, scale));

    return level;
}

/******************************************************************************
*
*     Function     : filter_bank
*     Purpose      : Divide input signal into bands and calculate level of
*                    the signal in each band
*
*******************************************************************************/

static void filter_bank(
        VadVars * st,                         /* i/o : State struct               */
        Word16 in[],                          /* i   : input frame                */
        Word16 level[]                        /* o   : signal levels at each band */
        )
{
    Word32 i;
    Word16 tmp_buf[FRAME_LEN];

    /* shift input 1 bit down for safe scaling */
    for (i = 0; i < FRAME_LEN; i++)
    {
        tmp_buf[i] = in[i] >> 1;
    }

    /* run the filter bank */
    for (i = 0; i < 128; i++)
    {
        filter5(&tmp_buf[2 * i], &tmp_buf[2 * i + 1], st->a_data5[0]);
    }
    for (i = 0; i < 64; i++)
    {
        filter5(&tmp_buf[4 * i], &tmp_buf[4 * i + 2], st->a_data5[1]);
        filter5(&tmp_buf[4 * i + 1], &tmp_buf[4 * i + 3], st->a_data5[2]);
    }
    for (i = 0; i < 32; i++)
    {
        filter5(&tmp_buf[8 * i], &tmp_buf[8 * i + 4], st->a_data5[3]);
        filter5(&tmp_buf[8 * i + 2], &tmp_buf[8 * i + 6], st->a_data5[4]);
        filter3(&tmp_buf[8 * i + 3], &tmp_buf[8 * i + 7], &st->a_data3[0]);
    }
    for (i = 0; i < 16; i++)
    {
        filter3(&tmp_buf[16 * i + 0], &tmp_buf[16 * i + 8], &st->a_data3[1]);
        filter3(&tmp_buf[16 * i + 4], &tmp_buf[16 * i + 12], &st->a_data3[2]);
        filter3(&tmp_buf[16 * i + 6], &tmp_buf[16 * i + 14], &st->a_data3[3]);
    }

    for (i = 0; i < 8; i++)
    {
        filter3(&tmp_buf[32 * i + 0], &tmp_buf[32 * i + 16], &st->a_data3[4]);
        filter3(&tmp_buf[32 * i + 8], &tmp_buf[32 * i + 24], &st->a_data3[5]);
    }

    /* calculate levels in each frequency band */

    /* 4800 - 6400 Hz */
    level[11] = level_calculation(tmp_buf, &st->sub_level[11], 16, 64, 4, 1, 14);
    /* 4000 - 4800 Hz */
    level[10] = level_calculation(tmp_buf, &st->sub_level[10], 8, 32, 8, 7, 15);
    /* 3200 - 4000 Hz */
    level[9] = level_calculation(tmp_buf, &st->sub_level[9],8, 32, 8, 3, 15);
    /* 2400 - 3200 Hz */
    level[8] = level_calculation(tmp_buf, &st->sub_level[8],8, 32, 8, 2, 15);
    /* 2000 - 2400 Hz */
    level[7] = level_calculation(tmp_buf, &st->sub_level[7],4, 16, 16, 14, 16);
    /* 1600 - 2000 Hz */
    level[6] = level_calculation(tmp_buf, &st->sub_level[6],4, 16, 16, 6, 16);
    /* 1200 - 1600 Hz */
    level[5] = level_calculation(tmp_buf, &st->sub_level[5],4, 16, 16, 4, 16);
    /* 800 - 1200 Hz */
    level[4] = level_calculation(tmp_buf, &st->sub_level[4],4, 16, 16, 12, 16);
    /* 600 - 800 Hz */
    level[3] = level_calculation(tmp_buf, &st->sub_level[3],2, 8, 32, 8, 17);
    /* 400 - 600 Hz */
    level[2] = level_calculation(tmp_buf, &st->sub_level[2],2, 8, 32, 24, 17);
    /* 200 - 400 Hz */
    level[1] = level_calculation(tmp_buf, &st->sub_level[1],2, 8, 32, 16, 17);
    /* 0 - 200 Hz */
    level[0] = level_calculation(tmp_buf, &st->sub_level[0],2, 8, 32, 0, 17);
}

/******************************************************************************
*
*     Function   : update_cntrl
*     Purpose    : Control update of the background noise estimate.
*
*******************************************************************************/

static void update_cntrl(
        VadVars * st,                         /* i/o : State structure                    */
        Word16 level[]                        /* i   : sub-band levels of the input frame */
        )
{
    Word32 i;
    Word16 num, temp, stat_rat, exp, denom;
    Word16 alpha;

    /* if a tone has been detected for a while, initialize stat_count */
    if (sub((Word16) (st->tone_flag & 0x7c00), 0x7c00) == 0)
    {
        st->stat_count = STAT_COUNT;
    } else
    {
        /* if 8 last vad-decisions have been "0", reinitialize stat_count */
        if ((st->vadreg & 0x7f80) == 0)
        {
            st->stat_count = STAT_COUNT;
        } else
        {
            stat_rat = 0;
            for (i = 0; i < COMPLEN; i++)
            {
                if(level[i] > st->ave_level[i])
                {
                    num = level[i];
                    denom = st->ave_level[i];
                } else
                {
                    num = st->ave_level[i];
                    denom = level[i];
                }
                /* Limit nimimum value of num and denom to STAT_THR_LEVEL */
                if(num < STAT_THR_LEVEL)
                {
                    num = STAT_THR_LEVEL;
                }
                if(denom < STAT_THR_LEVEL)
                {
                    denom = STAT_THR_LEVEL;
                }
                exp = norm_s(denom);
                denom = denom << exp;

                /* stat_rat = num/denom * 64 */
                temp = div_s(num >> 1, denom);
                stat_rat = add1(stat_rat, shr(temp, (8 - exp)));
            }

            /* compare stat_rat with a threshold and update stat_count */
            if(stat_rat > STAT_THR)
            {
                st->stat_count = STAT_COUNT;
            } else
            {
                if ((st->vadreg & 0x4000) != 0)
                {

                    if (st->stat_count != 0)
                    {
                        st->stat_count = st->stat_count - 1;
                    }
                }
            }
        }
    }

    /* Update average amplitude estimate for stationarity estimation */
    alpha = ALPHA4;
    if(st->stat_count == STAT_COUNT)
    {
        alpha = 32767;
    } else if ((st->vadreg & 0x4000) == 0)
    {
        alpha = ALPHA5;
    }
    for (i = 0; i < COMPLEN; i++)
    {
        st->ave_level[i] = add1(st->ave_level[i], vo_mult_r(alpha, vo_sub(level[i], st->ave_level[i])));
    }
}

/******************************************************************************
*
*     Function     : hangover_addition
*     Purpose      : Add hangover after speech bursts
*
*******************************************************************************/

static Word16 hangover_addition(                      /* return: VAD_flag indicating final VAD decision */
        VadVars * st,                         /* i/o : State structure                     */
        Word16 low_power,                     /* i   : flag power of the input frame    */
        Word16 hang_len,                      /* i   : hangover length */
        Word16 burst_len                      /* i   : minimum burst length for hangover addition */
        )
{
    /* if the input power (pow_sum) is lower than a threshold, clear counters and set VAD_flag to "0"         */
    if (low_power != 0)
    {
        st->burst_count = 0;
        st->hang_count = 0;
        return 0;
    }
    /* update the counters (hang_count, burst_count) */
    if ((st->vadreg & 0x4000) != 0)
    {
        st->burst_count = st->burst_count + 1;
        if(st->burst_count >= burst_len)
        {
            st->hang_count = hang_len;
        }
        return 1;
    } else
    {
        st->burst_count = 0;
        if (st->hang_count > 0)
        {
            st->hang_count = st->hang_count - 1;
            return 1;
        }
    }
    return 0;
}

/******************************************************************************
*
*     Function   : noise_estimate_update
*     Purpose    : Update of background noise estimate
*
*******************************************************************************/

static void noise_estimate_update(
        VadVars * st,                         /* i/o : State structure                       */
        Word16 level[]                        /* i   : sub-band levels of the input frame */
        )
{
    Word32 i;
    Word16 alpha_up, alpha_down, bckr_add = 2;

    /* Control update of bckr_est[] */
    update_cntrl(st, level);

    /* Choose update speed */
    if ((0x7800 & st->vadreg) == 0)
    {
        alpha_up = ALPHA_UP1;
        alpha_down = ALPHA_DOWN1;
    } else
    {
        if (st->stat_count == 0)
        {
            alpha_up = ALPHA_UP2;
            alpha_down = ALPHA_DOWN2;
        } else
        {
            alpha_up = 0;
            alpha_down = ALPHA3;
            bckr_add = 0;
        }
    }

    /* Update noise estimate (bckr_est) */
    for (i = 0; i < COMPLEN; i++)
    {
        Word16 temp;
        temp = (st->old_level[i] - st->bckr_est[i]);

        if (temp < 0)
        {                                  /* update downwards */
            st->bckr_est[i] = add1(-2, add(st->bckr_est[i],vo_mult_r(alpha_down, temp)));
            /* limit minimum value of the noise estimate to NOISE_MIN */
            if(st->bckr_est[i] < NOISE_MIN)
            {
                st->bckr_est[i] = NOISE_MIN;
            }
        } else
        {                                  /* update upwards */
            st->bckr_est[i] = add1(bckr_add, add1(st->bckr_est[i],vo_mult_r(alpha_up, temp)));

            /* limit maximum value of the noise estimate to NOISE_MAX */
            if(st->bckr_est[i] > NOISE_MAX)
            {
                st->bckr_est[i] = NOISE_MAX;
            }
        }
    }

    /* Update signal levels of the previous frame (old_level) */
    for (i = 0; i < COMPLEN; i++)
    {
        st->old_level[i] = level[i];
    }
}

/******************************************************************************
*
*     Function     : vad_decision
*     Purpose      : Calculates VAD_flag
*
*******************************************************************************/

static Word16 vad_decision(                           /* return value : VAD_flag */
        VadVars * st,                         /* i/o : State structure                       */
        Word16 level[COMPLEN],                /* i   : sub-band levels of the input frame */
        Word32 pow_sum                        /* i   : power of the input frame           */
        )
{
    Word32 i;
    Word32 L_snr_sum;
    Word32 L_temp;
    Word16 vad_thr, temp, noise_level;
    Word16 low_power_flag;
    Word16 hang_len, burst_len;
    Word16 ilog2_speech_level, ilog2_noise_level;
    Word16 temp2;

    /* Calculate squared sum of the input levels (level) divided by the background noise components
     * (bckr_est). */
    L_snr_sum = 0;
    for (i = 0; i < COMPLEN; i++)
    {
        Word16 exp;

        exp = norm_s(st->bckr_est[i]);
        temp = (st->bckr_est[i] << exp);
        temp = div_s((level[i] >> 1), temp);
        temp = shl(temp, (exp - (UNIRSHFT - 1)));
        L_snr_sum = L_mac(L_snr_sum, temp, temp);
    }

    /* Calculate average level of estimated background noise */
    L_temp = 0;
    for (i = 1; i < COMPLEN; i++)          /* ignore lowest band */
    {
        L_temp = vo_L_add(L_temp, st->bckr_est[i]);
    }

    noise_level = extract_h((L_temp << 12));
    /* if SNR is lower than a threshold (MIN_SPEECH_SNR), and increase speech_level */
    temp = vo_mult(noise_level, MIN_SPEECH_SNR) << 3;

    if(st->speech_level < temp)
    {
        st->speech_level = temp;
    }
    ilog2_noise_level = ilog2(noise_level);

    /* If SNR is very poor, speech_level is probably corrupted by noise level. This is correctred by
     * subtracting MIN_SPEECH_SNR*noise_level from speech level */
    ilog2_speech_level = ilog2(st->speech_level - temp);

    temp = add1(vo_mult(NO_SLOPE, (ilog2_noise_level - NO_P1)), THR_HIGH);

    temp2 = add1(SP_CH_MIN, vo_mult(SP_SLOPE, (ilog2_speech_level - SP_P1)));
    if (temp2 < SP_CH_MIN)
    {
        temp2 = SP_CH_MIN;
    }
    if (temp2 > SP_CH_MAX)
    {
        temp2 = SP_CH_MAX;
    }
    vad_thr = temp + temp2;

    if(vad_thr < THR_MIN)
    {
        vad_thr = THR_MIN;
    }
    /* Shift VAD decision register */
    st->vadreg = (st->vadreg >> 1);

    /* Make intermediate VAD decision */
    if(L_snr_sum > vo_L_mult(vad_thr, (512 * COMPLEN)))
    {
        st->vadreg = (Word16) (st->vadreg | 0x4000);
    }
    /* check if the input power (pow_sum) is lower than a threshold" */
    if(pow_sum < VAD_POW_LOW)
    {
        low_power_flag = 1;
    } else
    {
        low_power_flag = 0;
    }
    /* Update background noise estimates */
    noise_estimate_update(st, level);

    /* Calculate values for hang_len and burst_len based on vad_thr */
    hang_len = add1(vo_mult(HANG_SLOPE, (vad_thr - HANG_P1)), HANG_HIGH);
    if(hang_len < HANG_LOW)
    {
        hang_len = HANG_LOW;
    }
    burst_len = add1(vo_mult(BURST_SLOPE, (vad_thr - BURST_P1)), BURST_HIGH);

    return (hangover_addition(st, low_power_flag, hang_len, burst_len));
}

/******************************************************************************
*
*     Function : Estimate_Speech()
*     Purpose  : Estimate speech level
*
* Maximum signal level is searched and stored to the variable sp_max.
* The speech frames must locate within SP_EST_COUNT number of frames.
* Thus, noisy frames having occasional VAD = "1" decisions will not
* affect to the estimated speech_level.
*
*******************************************************************************/

static void Estimate_Speech(
        VadVars * st,                         /* i/o : State structure    */
        Word16 in_level                       /* level of the input frame */
        )
{
    Word16 alpha;

    /* if the required activity count cannot be achieved, reset counters */
    if((st->sp_est_cnt - st->sp_max_cnt) > (SP_EST_COUNT - SP_ACTIVITY_COUNT))
    {
        st->sp_est_cnt = 0;
        st->sp_max = 0;
        st->sp_max_cnt = 0;
    }
    st->sp_est_cnt += 1;

    if (((st->vadreg & 0x4000)||(in_level > st->speech_level)) && (in_level > MIN_SPEECH_LEVEL1))
    {
        /* update sp_max */
        if(in_level > st->sp_max)
        {
            st->sp_max = in_level;
        }
        st->sp_max_cnt += 1;

        if(st->sp_max_cnt >= SP_ACTIVITY_COUNT)
        {
            Word16 tmp;
            /* update speech estimate */
            tmp = (st->sp_max >> 1);      /* scale to get "average" speech level */

            /* select update speed */
            if(tmp > st->speech_level)
            {
                alpha = ALPHA_SP_UP;
            } else
            {
                alpha = ALPHA_SP_DOWN;
            }
            if(tmp > MIN_SPEECH_LEVEL2)
            {
                st->speech_level = add1(st->speech_level, vo_mult_r(alpha, vo_sub(tmp, st->speech_level)));
            }
            /* clear all counters used for speech estimation */
            st->sp_max = 0;
            st->sp_max_cnt = 0;
            st->sp_est_cnt = 0;
        }
    }
}

/******************************************************************************
*
*  Function:   wb_vad_init
*  Purpose:    Allocates state memory and initializes state memory
*
*******************************************************************************/

Word16 wb_vad_init(                        /* return: non-zero with error, zero for ok. */
        VadVars ** state,                     /* i/o : State structure    */
        VO_MEM_OPERATOR *pMemOP
        )
{
    VadVars *s;

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

    /* allocate memory */
    if ((s = (VadVars *) mem_malloc(pMemOP, sizeof(VadVars), 32, VO_INDEX_ENC_AMRWB)) == NULL)
    {
        fprintf(stderr, "vad_init: can not malloc state structure\n");
        return -1;
    }
    wb_vad_reset(s);

    *state = s;

    return 0;
}

/******************************************************************************
*
*  Function:   wb_vad_reset
*  Purpose:    Initializes state memory
*
*******************************************************************************/

Word16 wb_vad_reset(                       /* return: non-zero with error, zero for ok. */
        VadVars * state                       /* i/o : State structure    */
        )
{
    Word32 i, j;

    if (state == (VadVars *) NULL)
    {
        fprintf(stderr, "vad_reset: invalid parameter\n");
        return -1;
    }
    state->tone_flag = 0;
    state->vadreg = 0;
    state->hang_count = 0;
    state->burst_count = 0;
    state->hang_count = 0;

    /* initialize memory used by the filter bank */
    for (i = 0; i < F_5TH_CNT; i++)
    {
        for (j = 0; j < 2; j++)
        {
            state->a_data5[i][j] = 0;
        }
    }

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

    /* initialize the rest of the memory */
    for (i = 0; i < COMPLEN; i++)
    {
        state->bckr_est[i] = NOISE_INIT;
        state->old_level[i] = NOISE_INIT;
        state->ave_level[i] = NOISE_INIT;
        state->sub_level[i] = 0;
    }

    state->sp_est_cnt = 0;
    state->sp_max = 0;
    state->sp_max_cnt = 0;
    state->speech_level = SPEECH_LEVEL_INIT;
    state->prev_pow_sum = 0;
    return 0;
}

/******************************************************************************
*
*  Function:   wb_vad_exit
*  Purpose:    The memory used for state memory is freed
*
*******************************************************************************/

void wb_vad_exit(
        VadVars ** state,                      /* i/o : State structure    */
        VO_MEM_OPERATOR *pMemOP
        )
{
    if (state == NULL || *state == NULL)
        return;
    /* deallocate memory */
    mem_free(pMemOP, *state, VO_INDEX_ENC_AMRWB);
    *state = NULL;
    return;
}

/******************************************************************************
*
*     Function     : wb_vad_tone_detection
*     Purpose      : Search maximum pitch gain from a frame. Set tone flag if
*                    pitch gain is high. This is used to detect
*                    signaling tones and other signals with high pitch gain.
*
*******************************************************************************/

void wb_vad_tone_detection(
        VadVars * st,                         /* i/o : State struct            */
        Word16 p_gain                         /* pitch gain      */
        )
{
    /* update tone flag */
    st->tone_flag = (st->tone_flag >> 1);

    /* if (pitch_gain > TONE_THR) set tone flag */
    if (p_gain > TONE_THR)
    {
        st->tone_flag = (Word16) (st->tone_flag | 0x4000);
    }
}

/******************************************************************************
*
*     Function     : wb_vad
*     Purpose      : Main program for Voice Activity Detection (VAD) for AMR
*
*******************************************************************************/

Word16 wb_vad(                                /* Return value : VAD Decision, 1 = speech, 0 = noise */
        VadVars * st,                         /* i/o : State structure                 */
        Word16 in_buf[]                       /* i   : samples of the input frame   */
         )
{
    Word16 level[COMPLEN];
    Word32 i;
    Word16 VAD_flag, temp;
    Word32 L_temp, pow_sum;

    /* Calculate power of the input frame. */
    L_temp = 0L;
    for (i = 0; i < FRAME_LEN; i++)
    {
        L_temp = L_mac(L_temp, in_buf[i], in_buf[i]);
    }

    /* pow_sum = power of current frame and previous frame */
    pow_sum = L_add(L_temp, st->prev_pow_sum);

    /* save power of current frame for next call */
    st->prev_pow_sum = L_temp;

    /* If input power is very low, clear tone flag */
    if (pow_sum < POW_TONE_THR)
    {
        st->tone_flag = (Word16) (st->tone_flag & 0x1fff);
    }
    /* Run the filter bank and calculate signal levels at each band */
    filter_bank(st, in_buf, level);

    /* compute VAD decision */
    VAD_flag = vad_decision(st, level, pow_sum);

    /* Calculate input level */
    L_temp = 0;
    for (i = 1; i < COMPLEN; i++)          /* ignore lowest band */
    {
        L_temp = vo_L_add(L_temp, level[i]);
    }

    temp = extract_h(L_temp << 12);

    Estimate_Speech(st, temp);             /* Estimate speech level */
    return (VAD_flag);
}