xref: /frameworks/base/media/libstagefright/codecs/amrnb/common/src/vad1.cpp

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

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

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

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

 Description: Updated template used to PV coding template.
 Changed to accept the pOverflow flag for EPOC compatibility.

 Description: Made changes per review comments
 (1) Removed include of "count.h"
 (2) Replaced "basic_op.h" with individual include files
 (3) Removed some unnecessary instances of sub().

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

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

 Description: Changed round function name to pv_round to avoid conflict with
              round function in C standard library.

 Who:                           Date:
 Description:

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


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

/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/

#include <stdlib.h>
#include <string.h>

#include "vad.h"
#include "typedef.h"
#include "shr.h"
#include "basic_op.h"
#include "cnst_vad.h"

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

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

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

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

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

 Inputs:
    data -- array of type Word16 -- filter memory
    in   -- array of type Word16 -- input signal

 Outputs:
    data -- array of type Word16 -- filter memory
    out  -- array of type Word16 -- output values, every other
                                    output is low-pass part and
                                    other is high-pass part every

    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Scale input down by one bit. Calculate 5th order
                half-band lowpass/highpass filter pair with
                decimation.
------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static void first_filter_stage(
    Word16 in[],      /* i   : input signal                  */
    Word16 out[],     /* o   : output values, every other    */
    /*       output is low-pass part and   */
    /*       other is high-pass part every */
    Word16 data[],    /* i/o : filter memory                 */
    Flag  *pOverflow  /* o : Flag set when overflow occurs   */
)
{
    Word16 temp0;
    Word16 temp1;
    Word16 temp2;
    Word16 temp3;
    Word16 i;
    Word16 data0;
    Word16 data1;

    data0 = data[0];
    data1 = data[1];

    for (i = 0; i < FRAME_LEN / 4; i++)
    {
        temp0 = mult(COEFF5_1, data0, pOverflow);
        temp1 = shr(in[4*i+0], 2, pOverflow);
        temp0 = sub(temp1, temp0, pOverflow);

        temp1 = mult(COEFF5_1, temp0, pOverflow);
        temp1 = add(data0, temp1, pOverflow);

        temp3 = mult(COEFF5_2, data1, pOverflow);
        temp2 = shr(in[4*i+1], 2, pOverflow);

        temp3 = sub(temp2, temp3, pOverflow);

        temp2 = mult(COEFF5_2, temp3, pOverflow);
        temp2 = add(data1, temp2, pOverflow);

        out[4*i+0] = add(temp1, temp2, pOverflow);
        out[4*i+1] = sub(temp1, temp2, pOverflow);

        temp1 = mult(COEFF5_1, temp0, pOverflow);
        temp2 = shr(in[4*i+2], 2, pOverflow);
        data0 = sub(temp2, temp1, pOverflow);

        temp1 = mult(COEFF5_1, data0, pOverflow);
        temp1 = add(temp0, temp1, pOverflow);

        data1 = mult(COEFF5_2, temp3, pOverflow);
        temp2 = shr(in[4*i+3], 2, pOverflow);
        data1 = sub(temp2, data1, pOverflow);

        temp2 = mult(COEFF5_2, data1, pOverflow);
        temp2 = add(temp3, temp2, pOverflow);

        out[4*i+2] = add(temp1, temp2, pOverflow);
        out[4*i+3] = sub(temp1, temp2, pOverflow);
    }

    data[0] = data0;
    data[1] = data1;
}


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

 Inputs:
    in0 -- array of type Word16 -- input values; output low-pass part
    in1 -- array of type Word16 -- input values; output high-pass part
    data -- array of type Word16 -- updated filter memory

 Outputs:
    in0 -- array of type Word16 -- input values; output low-pass part
    in1 -- array of type Word16 -- input values; output high-pass part
    data -- array of type Word16 -- updated filter memory
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Fifth-order half-band lowpass/highpass filter pair with
                decimation.
------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

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 : updated filter memory               */
                    Flag  *pOverflow  /* o : Flag set when overflow occurs       */
                   )
{
    Word16 temp0;
    Word16 temp1;
    Word16 temp2;

    temp0 = mult(COEFF5_1, data[0], pOverflow);
    temp0 = sub(*in0, temp0, pOverflow);

    temp1 = mult(COEFF5_1, temp0, pOverflow);
    temp1 = add(data[0], temp1, pOverflow);
    data[0] = temp0;

    temp0 = mult(COEFF5_2, data[1], pOverflow);
    temp0 = sub(*in1, temp0, pOverflow);

    temp2 = mult(COEFF5_2, temp0, pOverflow);
    temp2 = add(data[1], temp2, pOverflow);

    data[1] = temp0;

    temp0 = add(temp1, temp2, pOverflow);
    *in0 = shr(temp0, 1, pOverflow);

    temp0 = sub(temp1, temp2, pOverflow);
    *in1 = shr(temp0, 1, pOverflow);
}




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


 Inputs:
    in0 -- array of type Word16 -- input values; output low-pass part
    in1 -- array of type Word16 -- input values; output high-pass part
    data -- array of type Word16 -- updated filter memory

 Outputs:
    in0 -- array of type Word16 -- input values; output low-pass part
    in1 -- array of type Word16 -- input values; output high-pass part
    data -- array of type Word16 -- updated filter memory
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Third-order half-band lowpass/highpass filter pair with
                decimation.
------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

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 : updated filter memory               */
    Flag  *pOverflow  /* o : Flag set when overflow occurs         */
)
{
    Word16 temp1;
    Word16 temp2;

    temp1 = mult(COEFF3, *data, pOverflow);
    temp1 = sub(*in1, temp1, pOverflow);

    temp2 = mult(COEFF3, temp1, pOverflow);
    temp2 = add(*data, temp2, pOverflow);

    *data = temp1;

    temp1 = sub(*in0, temp2, pOverflow);

    *in1 = shr(temp1, 1, pOverflow);

    temp1 = add(*in0, temp2, pOverflow);

    *in0 = shr(temp1, 1, pOverflow);
}




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

 Inputs:
    data -- array of type Word16 -- signal buffer
    sub_level -- pointer to type Word16 -- level calculated at the end of
                                           the previous frame

    count1 -- Word16 -- number of samples to be counted
    count2 -- Word16 -- number of samples to be counted
    ind_m  -- Word16 -- step size for the index of the data buffer
    ind_a  -- Word16 -- starting index of the data buffer
    scale  -- Word16 -- scaling for the level calculation

 Outputs:
    sub_level -- pointer to tyep Word16 -- level of signal calculated from the
                                           last (count2 - count1) samples.
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    signal level

 Global Variables Used:


 Local Variables Needed:
    None

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

 Purpose      : Calculate signal level in a sub-band. Level is calculated
                by summing absolute values of the input data.

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static Word16 level_calculation(
    Word16 data[],     /* i   : signal buffer                                */
    Word16 *sub_level, /* i   : level calculate 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            */
    Flag  *pOverflow   /* o : Flag set when overflow occurs                  */
)
{
    Word32 l_temp1;
    Word32 l_temp2;
    Word16 level;
    Word16 i;

    l_temp1 = 0L;

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

    l_temp2 = L_add(l_temp1, L_shl(*sub_level, sub(16, scale, pOverflow), pOverflow), pOverflow);
    *sub_level = extract_h(L_shl(l_temp1, scale, pOverflow));

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

    return level;
}




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

 Inputs:
    st -- pointer to type vadState1 --  State struct
    in -- array of type Word16 -- input frame

 Outputs:
    level -- array of type Word16 -- signal levels at each band
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Divides input signal into 9-bands and calculas level of
                the signal in each band

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static void filter_bank(
    vadState1 *st,    /* i/o : State struct                    */
    Word16 in[],      /* i   : input frame                     */
    Word16 level[],   /* 0   : signal levels at each band      */
    Flag  *pOverflow  /* o   : Flag set when overflow occurs   */
)
{
    Word16 i;
    Word16 tmp_buf[FRAME_LEN];

    /* calculate the filter bank */

    first_filter_stage(in, tmp_buf, st->a_data5[0], pOverflow);

    for (i = 0; i < FRAME_LEN / 4; i++)
    {
        filter5(&tmp_buf[4*i], &tmp_buf[4*i+2], st->a_data5[1], pOverflow);
        filter5(&tmp_buf[4*i+1], &tmp_buf[4*i+3], st->a_data5[2], pOverflow);
    }
    for (i = 0; i < FRAME_LEN / 8; i++)
    {
        filter3(&tmp_buf[8*i+0], &tmp_buf[8*i+4], &st->a_data3[0], pOverflow);
        filter3(&tmp_buf[8*i+2], &tmp_buf[8*i+6], &st->a_data3[1], pOverflow);
        filter3(&tmp_buf[8*i+3], &tmp_buf[8*i+7], &st->a_data3[4], pOverflow);
    }

    for (i = 0; i < FRAME_LEN / 16; i++)
    {
        filter3(&tmp_buf[16*i+0], &tmp_buf[16*i+8], &st->a_data3[2], pOverflow);
        filter3(&tmp_buf[16*i+4], &tmp_buf[16*i+12], &st->a_data3[3], pOverflow);
    }

    /* calculate levels in each frequency band */

    /* 3000 - 4000 Hz*/
    level[8] = level_calculation(tmp_buf, &st->sub_level[8], FRAME_LEN / 4 - 8,
                                 FRAME_LEN / 4, 4, 1, 15, pOverflow);
    /* 2500 - 3000 Hz*/
    level[7] = level_calculation(tmp_buf, &st->sub_level[7], FRAME_LEN / 8 - 4,
                                 FRAME_LEN / 8, 8, 7, 16, pOverflow);
    /* 2000 - 2500 Hz*/
    level[6] = level_calculation(tmp_buf, &st->sub_level[6], FRAME_LEN / 8 - 4,
                                 FRAME_LEN / 8, 8, 3, 16, pOverflow);
    /* 1500 - 2000 Hz*/
    level[5] = level_calculation(tmp_buf, &st->sub_level[5], FRAME_LEN / 8 - 4,
                                 FRAME_LEN / 8, 8, 2, 16, pOverflow);
    /* 1000 - 1500 Hz*/
    level[4] = level_calculation(tmp_buf, &st->sub_level[4], FRAME_LEN / 8 - 4,
                                 FRAME_LEN / 8, 8, 6, 16, pOverflow);
    /* 750 - 1000 Hz*/
    level[3] = level_calculation(tmp_buf, &st->sub_level[3], FRAME_LEN / 16 - 2,
                                 FRAME_LEN / 16, 16, 4, 16, pOverflow);
    /* 500 - 750 Hz*/
    level[2] = level_calculation(tmp_buf, &st->sub_level[2], FRAME_LEN / 16 - 2,
                                 FRAME_LEN / 16, 16, 12, 16, pOverflow);
    /* 250 - 500 Hz*/
    level[1] = level_calculation(tmp_buf, &st->sub_level[1], FRAME_LEN / 16 - 2,
                                 FRAME_LEN / 16, 16, 8, 16, pOverflow);
    /* 0 - 250 Hz*/
    level[0] = level_calculation(tmp_buf, &st->sub_level[0], FRAME_LEN / 16 - 2,
                                 FRAME_LEN / 16, 16, 0, 16, pOverflow);
}



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

 Inputs:
    st -- pointer to type vadState1 --  State struct
    level -- array of type Word16 -- sub-band levels of the input frame

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose    : Control update of the background noise estimate.
 Inputs     : pitch:      flags for pitch detection
              stat_count: stationary counter
              tone:       flags indicating presence of a tone
              complex:      flags for complex  detection
              vadreg:     intermediate VAD flags
 Output     : stat_count: stationary counter


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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static void update_cntrl(
    vadState1 *st,   /* i/o : State struct                       */
    Word16 level[],  /* i   : sub-band levels of the input frame */
    Flag  *pOverflow /* o   : Flag set when overflow occurs      */
)
{
    Word16 i;
    Word16 temp;
    Word16 stat_rat;
    Word16 exp;
    Word16 num;
    Word16 denom;
    Word16 alpha;

    /* handle highband complex signal input  separately       */
    /* if ther has been highband correlation for some time    */
    /* make sure that the VAD update speed is low for a while */
    if (st->complex_warning != 0)
    {
        if (st->stat_count < CAD_MIN_STAT_COUNT)
        {
            st->stat_count = CAD_MIN_STAT_COUNT;
        }
    }
    /* NB stat_count is allowed to be decreased by one below again  */
    /* deadlock in speech is not possible unless the signal is very */
    /* complex and need a high rate                                 */

    /* if fullband pitch or tone have been detected for a while, initialize stat_count */
    if (((Word16)(st->pitch & 0x6000) == 0x6000) ||
            ((Word16)(st->tone & 0x7c00) == 0x7c00))
    {
        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 = shl(denom, exp, pOverflow);

                /* stat_rat = num/denom * 64 */
                temp = shr(num, 1, pOverflow);
                temp = div_s(temp, denom);

                stat_rat = add(stat_rat, shr(temp, sub(8, exp, pOverflow), pOverflow), pOverflow);
            }

            /* 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 = sub(st->stat_count, 1, pOverflow);
                    }
                }
            }
        }
    }

    /* 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++)
    {
        temp = sub(level[i], st->ave_level[i], pOverflow);
        temp = mult_r(alpha, temp, pOverflow);

        st->ave_level[i] =
            add(
                st->ave_level[i],
                temp,
                pOverflow);
    }
}



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

 Inputs:
    noise_level -- Word16 -- average level of the noise estimates
    low_power   -- Word16 -- flag power of the input frame

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicato

 Returns:
    VAD_flag indicating final VAD decision (Word16)

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Function     : hangover_addition
 Purpose      : Add hangover for complex signal or after speech bursts
 Inputs       : burst_count:  counter for the length of speech bursts
                hang_count:   hangover counter
                vadreg:       intermediate VAD decision
 Outputs      : burst_count:  counter for the length of speech bursts
                hang_count:   hangover counter
 Return value : VAD_flag indicating final VAD decision


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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static Word16 hangover_addition(
    vadState1 *st,      /* i/o : State struct                     */
    Word16 noise_level, /* i   : average level of the noise       */
    /*       estimates                        */
    Word16 low_power,   /* i   : flag power of the input frame    */
    Flag  *pOverflow    /* o   : Flag set when overflow occurs    */
)
{
    Word16 hang_len;
    Word16 burst_len;

    /*
       Calculate burst_len and hang_len
       burst_len: number of consecutive intermediate vad flags with "1"-decision
                  required for hangover addition
       hang_len:  length of the hangover
       */

    if (noise_level > HANG_NOISE_THR)
    {
        burst_len = BURST_LEN_HIGH_NOISE;
        hang_len = HANG_LEN_HIGH_NOISE;
    }
    else
    {
        burst_len = BURST_LEN_LOW_NOISE;
        hang_len = HANG_LEN_LOW_NOISE;
    }

    /* if the input power (pow_sum) is lower than a threshold, clear
       counters and set VAD_flag to "0"  "fast exit"                 */
    if (low_power != 0)
    {
        st->burst_count = 0;
        st->hang_count = 0;
        st->complex_hang_count = 0;
        st->complex_hang_timer = 0;
        return 0;
    }

    if (st->complex_hang_timer > CVAD_HANG_LIMIT)
    {
        if (st->complex_hang_count < CVAD_HANG_LENGTH)
        {
            st->complex_hang_count = CVAD_HANG_LENGTH;
        }
    }

    /* long time very complex signal override VAD output function */
    if (st->complex_hang_count != 0)
    {
        st->burst_count = BURST_LEN_HIGH_NOISE;
        st->complex_hang_count = sub(st->complex_hang_count, 1, pOverflow);
        return 1;
    }
    else
    {
        /* let hp_corr work in from a noise_period indicated by the VAD */
        if (((st->vadreg & 0x3ff0) == 0) &&
                (st->corr_hp_fast > CVAD_THRESH_IN_NOISE))
        {
            return 1;
        }
    }

    /* update the counters (hang_count, burst_count) */
    if ((st->vadreg & 0x4000) != 0)
    {
        st->burst_count = add(st->burst_count, 1, pOverflow);

        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 = sub(st->hang_count, 1, pOverflow);
            return 1;
        }
    }
    return 0;
}



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

 Inputs:
    st -- pointer to type vadState1 --  State struct
    level -- array of type Word16 -- sub-band levels of the input frame

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose    : Update of background noise estimate
 Inputs     : bckr_est:   background noise estimate
              pitch:      flags for pitch detection
              stat_count: stationary counter
 Outputs    : bckr_est:   background noise estimate

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static void noise_estimate_update(
    vadState1 *st,    /* i/o : State struct                       */
    Word16 level[],   /* i   : sub-band levels of the input frame */
    Flag  *pOverflow  /* o : Flag set when overflow occurs        */
)
{
    Word16 i;
    Word16 alpha_up;
    Word16 alpha_down;
    Word16 bckr_add;

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

    /* Choose update speed */
    bckr_add = 2;

    if (((0x7800 & st->vadreg) == 0) &&
            ((st->pitch & 0x7800) == 0)
            && (st->complex_hang_count == 0))
    {
        alpha_up = ALPHA_UP1;
        alpha_down = ALPHA_DOWN1;
    }
    else
    {
        if ((st->stat_count == 0)
                && (st->complex_hang_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 = sub(st->old_level[i], st->bckr_est[i], pOverflow);

        if (temp < 0)
        { /* update downwards*/
            temp = mult_r(alpha_down, temp, pOverflow);
            temp = add(st->bckr_est[i], temp, pOverflow);

            st->bckr_est[i] = add(-2, temp, pOverflow);

            /* 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 */
            temp = mult_r(alpha_up, temp, pOverflow);
            temp = add(st->bckr_est[i], temp, pOverflow);
            st->bckr_est[i] = add(bckr_add, temp, pOverflow);

            /* 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 NAME: complex_estimate_adapt
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    st -- pointer to type vadState1 --  State struct
    low_power -- Word16 -- very low level flag of the input frame

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Function   : complex_estimate_adapt
 Purpose    : Update/adapt of complex signal estimate
 Inputs     : low_power:   low signal power flag
 Outputs    : st->corr_hp_fast:   long term complex signal estimate

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static void complex_estimate_adapt(
    vadState1 *st,      /* i/o : VAD state struct                       */
    Word16 low_power,   /* i   : very low level flag of the input frame */
    Flag  *pOverflow    /* o : Flag set when overflow occurs            */
)
{
    Word16 alpha;            /* Q15 */
    Word32 L_tmp;            /* Q31 */


    /* adapt speed on own state */
    if (st->best_corr_hp < st->corr_hp_fast) /* decrease */
    {
        if (st->corr_hp_fast < CVAD_THRESH_ADAPT_HIGH)
        {  /* low state  */
            alpha = CVAD_ADAPT_FAST;
        }
        else
        {  /* high state */
            alpha = CVAD_ADAPT_REALLY_FAST;
        }
    }
    else  /* increase */
    {
        if (st->corr_hp_fast < CVAD_THRESH_ADAPT_HIGH)
        {
            alpha = CVAD_ADAPT_FAST;
        }
        else
        {
            alpha = CVAD_ADAPT_SLOW;
        }
    }

    L_tmp = L_deposit_h(st->corr_hp_fast);
    L_tmp = L_msu(L_tmp, alpha, st->corr_hp_fast, pOverflow);
    L_tmp = L_mac(L_tmp, alpha, st->best_corr_hp, pOverflow);
    st->corr_hp_fast = pv_round(L_tmp, pOverflow);           /* Q15 */

    if (st->corr_hp_fast < CVAD_MIN_CORR)
    {
        st->corr_hp_fast = CVAD_MIN_CORR;
    }

    if (low_power != 0)
    {
        st->corr_hp_fast = CVAD_MIN_CORR;
    }
}


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

 Inputs:
    st -- pointer to type vadState1 --  State struct
    low_power -- Word16 -- flag power of the input frame

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator


 Returns:
    the complex background decision

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : complex background decision
 Return value : the complex background decision

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static Word16 complex_vad(
    vadState1 *st,    /* i/o : VAD state struct              */
    Word16 low_power, /* i   : flag power of the input frame */
    Flag  *pOverflow  /* o : Flag set when overflow occurs   */
)
{
    st->complex_high = shr(st->complex_high, 1, pOverflow);
    st->complex_low = shr(st->complex_low, 1, pOverflow);

    if (low_power == 0)
    {
        if (st->corr_hp_fast > CVAD_THRESH_ADAPT_HIGH)
        {
            st->complex_high |= 0x4000;
        }

        if (st->corr_hp_fast > CVAD_THRESH_ADAPT_LOW)
        {
            st->complex_low |= 0x4000;
        }
    }

    if (st->corr_hp_fast > CVAD_THRESH_HANG)
    {
        st->complex_hang_timer = add(st->complex_hang_timer, 1, pOverflow);
    }
    else
    {
        st->complex_hang_timer =  0;
    }

    return ((Word16)(st->complex_high & 0x7f80) == 0x7f80 ||
            (Word16)(st->complex_low & 0x7fff) == 0x7fff);
}


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

 Inputs:
    st -- pointer to type vadState1 --  State struct
    level -- array of type Word16 -- sub-band levels of the input frame
    pow_sum -- Word32 -- power of the input frame

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    VAD_flag (Word16)

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Calculates VAD_flag
 Inputs       : bckr_est:    background noise estimate
                vadreg:      intermediate VAD flags
 Outputs      : noise_level: average level of the noise estimates
                vadreg:      intermediate VAD flags
 Return value : VAD_flag

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

static Word16 vad_decision(
    vadState1 *st,         /* i/o : State struct                       */
    Word16 level[COMPLEN], /* i   : sub-band levels of the input frame */
    Word32 pow_sum,        /* i   : power of the input frame           */
    Flag  *pOverflow       /* o : Flag set when overflow occurs        */
)
{
    Word16 i;
    Word16 snr_sum;
    Word32 L_temp;
    Word16 vad_thr;
    Word16 temp;
    Word16 noise_level;
    Word16 low_power_flag;
    Word16 temp1;

    /*
       Calculate squared sum of the input levels (level)
       divided by the background noise components (bckr_est).
       */
    L_temp = 0;

    for (i = 0; i < COMPLEN; i++)
    {
        Word16 exp;

        exp = norm_s(st->bckr_est[i]);
        temp = shl(st->bckr_est[i], exp, pOverflow);
        temp = div_s(shr(level[i], 1, pOverflow), temp);
        temp = shl(temp, sub(exp, UNIRSHFT - 1, pOverflow), pOverflow);
        L_temp = L_mac(L_temp, temp, temp, pOverflow);
    }

    snr_sum = extract_h(L_shl(L_temp, 6, pOverflow));
    snr_sum = mult(snr_sum, INV_COMPLEN, pOverflow);

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

    noise_level = extract_h(L_shl(L_temp, 13, pOverflow));

    /* Calculate VAD threshold */
    temp1 = sub(noise_level, VAD_P1, pOverflow);
    temp1 = mult(VAD_SLOPE, temp1, pOverflow);
    vad_thr = add(temp1, VAD_THR_HIGH, pOverflow);

    if (vad_thr < VAD_THR_LOW)
    {
        vad_thr = VAD_THR_LOW;
    }

    /* Shift VAD decision register */
    st->vadreg = shr(st->vadreg, 1, pOverflow);

    /* Make intermediate VAD decision */
    if (snr_sum > vad_thr)
    {
        st->vadreg |= 0x4000;
    }
    /* primary vad decsion made */

    /* check if the input power (pow_sum) is lower than a threshold" */
    if (L_sub(pow_sum, VAD_POW_LOW, pOverflow) < 0)
    {
        low_power_flag = 1;
    }
    else
    {
        low_power_flag = 0;
    }

    /* update complex signal estimate st->corr_hp_fast and hangover reset timer using */
    /* low_power_flag and corr_hp_fast  and various adaptation speeds                 */
    complex_estimate_adapt(st, low_power_flag, pOverflow);

    /* check multiple thresholds of the st->corr_hp_fast value */
    st->complex_warning = complex_vad(st, low_power_flag, pOverflow);

    /* Update speech subband vad background noise estimates */
    noise_estimate_update(st, level, pOverflow);

    /*  Add speech and complex hangover and return speech VAD_flag */
    /*  long term complex hangover may be added */
    st->speech_vad_decision = hangover_addition(st, noise_level, low_power_flag, pOverflow);

    return (st->speech_vad_decision);
}


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

 Inputs:
    state -- double pointer to type vadState1 -- pointer to memory to
                                                 be initialized.

 Outputs:
    state -- points to initalized area in memory.

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Allocates state memory and initializes state memory

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

Word16 vad1_init(vadState1 **state)
{
    vadState1* s;

    if (state == (vadState1 **) NULL)
    {
        return -1;
    }
    *state = NULL;

    /* allocate memory */
    if ((s = (vadState1 *) malloc(sizeof(vadState1))) == NULL)
    {
        return -1;
    }

    vad1_reset(s);

    *state = s;

    return 0;
}

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

 Inputs:
    state -- pointer to type vadState1 --  State struct

 Outputs:
    state -- pointer to type vadState1 --  State struct

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose:    Resets state memory to zero

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

Word16 vad1_reset(vadState1 *state)
{
    Word16 i;
    Word16 j;

    if (state == (vadState1 *) NULL)
    {
        return -1;
    }

    /* Initialize pitch detection variables */
    state->oldlag_count = 0;
    state->oldlag = 0;
    state->pitch = 0;
    state->tone = 0;

    state->complex_high = 0;
    state->complex_low = 0;
    state->complex_hang_timer = 0;

    state->vadreg = 0;

    state->stat_count = 0;
    state->burst_count = 0;
    state->hang_count = 0;
    state->complex_hang_count = 0;

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

    for (i = 0; i < 5; 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->best_corr_hp = CVAD_LOWPOW_RESET;

    state->speech_vad_decision = 0;
    state->complex_warning = 0;
    state->sp_burst_count = 0;

    state->corr_hp_fast = CVAD_LOWPOW_RESET;

    return 0;
}


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

 Inputs:
    state -- pointer to type vadState1 --  State struct

 Outputs:
    None

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

    The memory used for state memory is freed

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

void vad1_exit(vadState1 **state)
{
    if (state == NULL || *state == NULL)
        return;

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

    return;
}


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

 Inputs:
    best_corr_hp -- Word16 -- best Corr
    state -- pointer to type vadState1 --  State struct

 Outputs:
    state -- pointer to type vadState1 --  State struct

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : update vad->bestCorr_hp  complex signal feature state
------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

void vad_complex_detection_update(
    vadState1 *st,       /* i/o : State struct */
    Word16 best_corr_hp) /* i   : best Corr    */
{
    st->best_corr_hp = best_corr_hp;
}



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

 Inputs:
    st -- pointer to type vadState1 --  State struct
    t0 -- Word32 -- autocorrelation maxima
    t1 -- Word32 -- energy

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Set tone flag if pitch gain is high. This is used to detect
                signaling tones and other signals with high pitch gain.
 Inputs       : tone: flags indicating presence of a tone
 Outputs      : tone: flags indicating presence of a tone
------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

void vad_tone_detection(
    vadState1 *st,    /* i/o : State struct                       */
    Word32 t0,        /* i   : autocorrelation maxima             */
    Word32 t1,        /* i   : energy                             */
    Flag  *pOverflow  /* o : Flag set when overflow occurs        */
)
{
    Word16 temp;
    /*
       if (t0 > TONE_THR * t1)
       set tone flag
       */
    temp = pv_round(t1, pOverflow);

    if ((temp > 0) && (L_msu(t0, temp, TONE_THR, pOverflow) > 0))
    {
        st->tone |= 0x4000;
    }
}


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

 Inputs:
    one_lag_per_frame -- Word16 -- 1 if one open-loop lag is calculated per
                                   each frame, otherwise 0
    st -- pointer to type vadState1 --  State struct

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Update the tone flag register. Tone flags are shifted right
                by one bit. This function should be called from the speech
                encoder before call to Vad_tone_detection() function.

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

void vad_tone_detection_update(
    vadState1 *st,              /* i/o : State struct           */
    Word16 one_lag_per_frame,   /* i   : 1 if one open-loop lag */
    /*       is calculated per each */
    /*       frame, otherwise 0     */
    Flag *pOverflow             /* o   : Flags overflow         */
)
{
    /* Shift tone flags right by one bit */
    st->tone = shr(st->tone, 1, pOverflow);

    /* If open-loop lag is calculated only once in each frame, do extra update
       and assume that the other tone flag of the frame is one. */
    if (one_lag_per_frame != 0)
    {
        st->tone = shr(st->tone, 1, pOverflow);
        st->tone |= 0x2000;
    }
}


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

 Inputs:
    T_op -- array of type Word16 -- speech encoder open loop lags
    st -- pointer to type vadState1 --  State struct

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Test whether signal contains pitch or other periodic
                component.
 Return value : Boolean voiced / unvoiced decision in state variable

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

void vad_pitch_detection(
    vadState1 *st,    /* i/o : State struct                  */
    Word16 T_op[],    /* i   : speech encoder open loop lags */
    Flag  *pOverflow  /* o : Flag set when overflow occurs   */
)
{
    Word16 lagcount;
    Word16 i;
    Word16 temp;

    lagcount = 0;

    for (i = 0; i < 2; i++)
    {
        temp = sub(st->oldlag, T_op[i], pOverflow);
        temp = abs_s(temp);

        if (temp < LTHRESH)
        {
            lagcount = add(lagcount, 1, pOverflow);
        }

        /* Save the current LTP lag */
        st->oldlag = T_op[i];
    }

    /* Make pitch decision.
       Save flag of the pitch detection to the variable pitch.
       */
    st->pitch = shr(st->pitch, 1, pOverflow);

    temp =
        add(
            st->oldlag_count,
            lagcount,
            pOverflow);

    if (temp >= NTHRESH)
    {
        st->pitch |= 0x4000;
    }

    /* Update oldlagcount */
    st->oldlag_count = lagcount;
}

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

 Inputs:
    st -- pointer to type vadState1 --  State struct
    in_buf -- array of type Word16 -- samples of the input frame

 Outputs:
    st -- pointer to type vadState1 --  State struct
    pOverflow -- pointer to type Flag -- overflow indicator

 Returns:
    VAD Decision, 1 = speech, 0 = noise

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

 Purpose      : Main program for Voice Activity Detection (VAD) for AMR
 Return value : VAD Decision, 1 = speech, 0 = noise

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

 None

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

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

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


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

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

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

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

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

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

Word16 vad1(
    vadState1 *st,    /* i/o : State struct                       */
    Word16 in_buf[],  /* i   : samples of the input frame         */
    Flag  *pOverflow  /* o   : Flag set when overflow occurs      */
)
{
    Word16 level[COMPLEN];
    Word32 pow_sum;
    Word16 i;

    /* Calculate power of the input frame. */
    pow_sum = 0L;

    for (i = 0; i < FRAME_LEN; i++)
    {
        pow_sum = L_mac(pow_sum, in_buf[i-LOOKAHEAD], in_buf[i-LOOKAHEAD], pOverflow);
    }

    /*
      If input power is very low, clear pitch flag of the current frame
      */
    if (L_sub(pow_sum, POW_PITCH_THR, pOverflow) < 0)
    {
        st->pitch = st->pitch & 0x3fff;
    }

    /*
      If input power is very low, clear complex flag of the "current" frame
      */
    if (L_sub(pow_sum, POW_COMPLEX_THR, pOverflow) < 0)
    {
        st->complex_low = st->complex_low & 0x3fff;
    }

    /*
      Run the filter bank which calculates signal levels at each band
      */
    filter_bank(st, in_buf, level, pOverflow);

    return (vad_decision(st, level, pow_sum, pOverflow));
}