/* | |
** 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); | |
} | |