diff options
Diffstat (limited to 'media/libstagefright/codecs/amrnb/enc/src/p_ol_wgh.cpp')
-rw-r--r-- | media/libstagefright/codecs/amrnb/enc/src/p_ol_wgh.cpp | 989 |
1 files changed, 989 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/amrnb/enc/src/p_ol_wgh.cpp b/media/libstagefright/codecs/amrnb/enc/src/p_ol_wgh.cpp new file mode 100644 index 0000000..68d7345 --- /dev/null +++ b/media/libstagefright/codecs/amrnb/enc/src/p_ol_wgh.cpp @@ -0,0 +1,989 @@ +/* ------------------------------------------------------------------ + * 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/p_ol_wgh.c + Funtions: p_ol_wgh_init + p_ol_wgh_reset + p_ol_wgh_exit + Lag_max + Pitch_ol_wgh + + Date: 02/05/2002 +------------------------------------------------------------------------------ + REVISION HISTORY + + Description: t0 was not being declared as Word32. + + 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. + + Description: + +------------------------------------------------------------------------------ + MODULE DESCRIPTION + + The modules in this file compute the open loop pitch lag with weighting. +------------------------------------------------------------------------------ +*/ + + +/*---------------------------------------------------------------------------- +; INCLUDES +----------------------------------------------------------------------------*/ +#include <stdlib.h> + +#include "p_ol_wgh.h" +#include "typedef.h" +#include "cnst.h" +#include "basic_op.h" +#include "gmed_n.h" +#include "inv_sqrt.h" +#include "vad1.h" +#include "calc_cor.h" +#include "hp_max.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: p_ol_wgh_init +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + Inputs + state = pointer to a pointer of structure type pitchOLWghtState + + Outputs: + None + + Returns: + 0 if the memory allocation is a success + -1 if the memory allocation fails + + Global Variables Used: + None. + + Local Variables Needed: + None. + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + This function allocates state memory and initializes state memory + +------------------------------------------------------------------------------ + REQUIREMENTS + + None. + +------------------------------------------------------------------------------ + REFERENCES + + p_ol_wgh.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + +int p_ol_wgh_init (pitchOLWghtState **state) +{ + pitchOLWghtState* s; + + if (state == (pitchOLWghtState **) NULL){ + // fprintf(stderr, "p_ol_wgh_init: invalid parameter\n"); + return -1; + } + *state = NULL; + + // allocate memory + if ((s= (pitchOLWghtState *) malloc(sizeof(pitchOLWghtState))) == NULL){ + // fprintf(stderr, "p_ol_wgh_init: can not malloc state structure\n"); + return -1; + } + + p_ol_wgh_reset(s); + + *state = s; + + return 0; +} + +------------------------------------------------------------------------------ + 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 p_ol_wgh_init(pitchOLWghtState **state) +{ + pitchOLWghtState* s; + + if (state == (pitchOLWghtState **) NULL) + { + /* fprintf(stderr, "p_ol_wgh_init: invalid parameter\n"); */ + return -1; + } + *state = NULL; + + /* allocate memory */ + if ((s = (pitchOLWghtState *) malloc(sizeof(pitchOLWghtState))) == NULL) + { + /* fprintf(stderr, "p_ol_wgh_init: can not malloc state structure\n"); */ + return -1; + } + + p_ol_wgh_reset(s); + + *state = s; + + return 0; +} + +/*---------------------------------------------------------------------------- +; End Function: p_ol_wgh_init +----------------------------------------------------------------------------*/ + +/* +------------------------------------------------------------------------------ + FUNCTION NAME: p_ol_wgh_reset +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + Inputs + st = pointer to structure type pitchOLWghtState + + Outputs: + None + + Returns: + 0 if the memory initialization is a success + -1 if the memory initialization fails + + Global Variables Used: + None. + + Local Variables Needed: + None. + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + This function initializes state memory to zero + +------------------------------------------------------------------------------ + REQUIREMENTS + + None. + +------------------------------------------------------------------------------ + REFERENCES + + p_ol_wgh.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + +int p_ol_wgh_reset (pitchOLWghtState *st) +{ + if (st == (pitchOLWghtState *) NULL){ + // fprintf(stderr, "p_ol_wgh_reset: invalid parameter\n"); + return -1; + } + + // Reset pitch search states + st->old_T0_med = 40; + st->ada_w = 0; + st->wght_flg = 0; + + return 0; +} + +------------------------------------------------------------------------------ + 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 p_ol_wgh_reset(pitchOLWghtState *st) +{ + if (st == (pitchOLWghtState *) NULL) + { + /* fprintf(stderr, "p_ol_wgh_reset: invalid parameter\n"); */ + return -1; + } + + /* Reset pitch search states */ + st->old_T0_med = 40; + st->ada_w = 0; + st->wght_flg = 0; + + return 0; +} + +/*---------------------------------------------------------------------------- +; End Function: p_ol_wgh_reset +----------------------------------------------------------------------------*/ + +/* +------------------------------------------------------------------------------ + FUNCTION NAME: p_ol_wgh_exit +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + Inputs + st = pointer to a pointer of structure type pitchOLWghtState + + Outputs: + None + + Returns: + 0 if the memory initialization is a success + -1 if the memory initialization fails + + Global Variables Used: + None. + + Local Variables Needed: + None. + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + This function frees the memory used for state memory + +------------------------------------------------------------------------------ + REQUIREMENTS + + None. + +------------------------------------------------------------------------------ + REFERENCES + + p_ol_wgh.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + +void p_ol_wgh_exit (pitchOLWghtState **state) +{ + if (state == NULL || *state == NULL) + return; + + // deallocate memory + free(*state); + *state = NULL; + + return; +} + +------------------------------------------------------------------------------ + 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 p_ol_wgh_exit(pitchOLWghtState **state) +{ + if (state == NULL || *state == NULL) + return; + + /* deallocate memory */ + free(*state); + *state = NULL; + + return; +} + + +/*---------------------------------------------------------------------------- +; End Function: p_ol_wgh_exit +----------------------------------------------------------------------------*/ +/* +------------------------------------------------------------------------------ + FUNCTION NAME: Lag_max +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + Inputs: + corr = pointer to buffer of correlation values (Word32) + scal_sig = pointer to buffer of scaled signal values (Word16) + scal_fac = scaled signal factor (Word16) + scal_flag = EFR compatible scaling flag (Word16) + L_frame = length of frame to compute pitch (Word16) + lag_max = maximum lag (Word16) + lag_min = minimum lag (Word16) + cor_max = pointer to the normalized correlation of selected lag (Word16) + rmax = pointer to max(<s[i]*s[j]>), (Word32) + r0 = pointer to the residual energy (Word32) + dtx = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag) + pOverflow = Pointer to overflow (Flag) + + Outputs: + cor_max contains the newly calculated normalized correlation of the + selected lag + rmax contains the newly calculated max(<s[i]*s[j]>) + r0 contains the newly calculated residual energy + pOverflow -> 1 if the math functions called by this routine saturate. + + Returns: + p_max = lag of the max correlation found (Word16) + + Global Variables Used: + None. + + Local Variables Needed: + None. + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + This function finds the lag that has maximum correlation of scal_sig[] in a + given delay range. + The correlation is given by + cor[t] = <scal_sig[n],scal_sig[n-t]>, t=lag_min,...,lag_max + The functions outputs the maximum correlation after normalization and the + corresponding lag. + +------------------------------------------------------------------------------ + REQUIREMENTS + + None. + +------------------------------------------------------------------------------ + REFERENCES + + p_ol_wgh.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + +static Word16 Lag_max ( // o : lag found + vadState *vadSt, // i/o : VAD state struct + Word32 corr[], // i : correlation vector. + Word16 scal_sig[], // i : scaled signal. + Word16 L_frame, // i : length of frame to compute pitch + Word16 lag_max, // i : maximum lag + Word16 lag_min, // i : minimum lag + Word16 old_lag, // i : old open-loop lag + Word16 *cor_max, // o : normalized correlation of selected lag + Word16 wght_flg, // i : is weighting function used + Word16 *gain_flg, // o : open-loop flag + Flag dtx // i : dtx flag; use dtx=1, do not use dtx=0 + ) +{ + Word16 i, j; + Word16 *p, *p1; + Word32 max, t0; + Word16 t0_h, t0_l; + Word16 p_max; + const Word16 *ww, *we; + Word32 t1; + + ww = &corrweight[250]; + we = &corrweight[123 + lag_max - old_lag]; + + max = MIN_32; + p_max = lag_max; + + for (i = lag_max; i >= lag_min; i--) + { + t0 = corr[-i]; + + // Weighting of the correlation function. + L_Extract (corr[-i], &t0_h, &t0_l); + t0 = Mpy_32_16 (t0_h, t0_l, *ww); + ww--; + if (wght_flg > 0) { + // Weight the neighbourhood of the old lag + L_Extract (t0, &t0_h, &t0_l); + t0 = Mpy_32_16 (t0_h, t0_l, *we); + we--; + } + + if (L_sub (t0, max) >= 0) + { + max = t0; + p_max = i; + } + } + + p = &scal_sig[0]; + p1 = &scal_sig[-p_max]; + t0 = 0; + t1 = 0; + + for (j = 0; j < L_frame; j++, p++, p1++) + { + t0 = L_mac (t0, *p, *p1); + t1 = L_mac (t1, *p1, *p1); + } + + if (dtx) + { // no test() call since this if is only in simulation env +#ifdef VAD2 + vadSt->L_Rmax = L_add(vadSt->L_Rmax, t0); // Save max correlation + vadSt->L_R0 = L_add(vadSt->L_R0, t1); // Save max energy +#else + // update and detect tone + vad_tone_detection_update (vadSt, 0); + vad_tone_detection (vadSt, t0, t1); +#endif + } + + // gain flag is set according to the open_loop gain + // is t2/t1 > 0.4 ? + *gain_flg = pv_round(L_msu(t0, pv_round(t1), 13107)); + + *cor_max = 0; + + return (p_max); +} + +------------------------------------------------------------------------------ + 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 Lag_max( /* o : lag found */ + vadState *vadSt, /* i/o : VAD state struct */ + Word32 corr[], /* i : correlation vector. */ + Word16 scal_sig[], /* i : scaled signal. */ + Word16 L_frame, /* i : length of frame to compute pitch */ + Word16 lag_max, /* i : maximum lag */ + Word16 lag_min, /* i : minimum lag */ + Word16 old_lag, /* i : old open-loop lag */ + Word16 *cor_max, /* o : normalized correlation of selected lag */ + Word16 wght_flg, /* i : is weighting function used */ + Word16 *gain_flg, /* o : open-loop flag */ + Flag dtx, /* i : dtx flag; use dtx=1, do not use dtx=0 */ + Flag *pOverflow /* o : overflow flag */ +) +{ + Word16 i; + Word16 j; + Word16 *p; + Word16 *p1; + Word32 max; + Word32 t0; + Word16 t0_h; + Word16 t0_l; + Word16 p_max; + const Word16 *ww; + const Word16 *we; + Word32 t1; + Word16 temp; + + ww = &corrweight[250]; + we = &corrweight[123 + lag_max - old_lag]; + + max = MIN_32; + p_max = lag_max; + + for (i = lag_max; i >= lag_min; i--) + { + t0 = corr[-i]; + + /* Weighting of the correlation function. */ + L_Extract(corr[-i], &t0_h, &t0_l, pOverflow); + t0 = Mpy_32_16(t0_h, t0_l, *ww, pOverflow); + ww--; + if (wght_flg > 0) + { + /* Weight the neighbourhood of the old lag. */ + L_Extract(t0, &t0_h, &t0_l, pOverflow); + t0 = Mpy_32_16(t0_h, t0_l, *we, pOverflow); + we--; + } + + /* if (L_sub (t0, max) >= 0) */ + if (t0 >= max) + { + max = t0; + p_max = i; + } + } + p = &scal_sig[0]; + p1 = &scal_sig[-p_max]; + t0 = 0; + t1 = 0; + + for (j = 0; j < L_frame; j++, p++, p1++) + { + t0 = L_mac(t0, *p, *p1, pOverflow); + t1 = L_mac(t1, *p1, *p1, pOverflow); + } + + if (dtx) + { /* no test() call since this if is only in simulation env */ +#ifdef VAD2 + /* Save max correlation */ + vadSt->L_Rmax = L_add(vadSt->L_Rmax, t0, pOverflow); + /* Save max energy */ + vadSt->L_R0 = L_add(vadSt->L_R0, t1, pOverflow); +#else + /* update and detect tone */ + vad_tone_detection_update(vadSt, 0, pOverflow); + vad_tone_detection(vadSt, t0, t1, pOverflow); +#endif + } + + /* gain flag is set according to the open_loop gain */ + /* is t2/t1 > 0.4 ? */ + temp = pv_round(t1, pOverflow); + t1 = L_msu(t0, temp, 13107, pOverflow); + *gain_flg = pv_round(t1, pOverflow); + + *cor_max = 0; + + return (p_max); +} +/*---------------------------------------------------------------------------- +; End Function: Lag_max +----------------------------------------------------------------------------*/ + +/* +------------------------------------------------------------------------------ + FUNCTION NAME: Pitch_ol_wgh +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + Inputs: + st = pointer to pitchOLWghtState structure + vadSt = pointer to a vadState structure + signal = pointer to buffer of signal used to compute the open loop + pitch where signal[-pit_max] to signal[-1] should be known + pit_min = 16 bit value specifies the minimum pitch lag + pit_max = 16 bit value specifies the maximum pitch lag + L_frame = 16 bit value specifies the length of frame to compute pitch + old_lags = pointer to history with old stored Cl lags (Word16) + ol_gain_flg = pointer to OL gain flag (Word16) + idx = 16 bit value specifies the frame index + dtx = Data of type 'Flag' used for dtx. Use dtx=1, do not use dtx=0 + pOverflow = pointer to Overflow indicator (Flag) + Outputs + st = The pitchOLWghtState may be modified + vadSt = The vadSt state structure may be modified. + pOverflow -> 1 if the math functions invoked by this routine saturate. + + Returns: + p_max1 = 16 bit value representing the open loop pitch lag. + + Global Variables Used: + None. + + Local Variables Needed: + None. + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + This function performs an open-loop pitch search with weighting +------------------------------------------------------------------------------ + REQUIREMENTS + + None. + +------------------------------------------------------------------------------ + REFERENCES + + pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + +Word16 Pitch_ol_wgh ( // o : open loop pitch lag + pitchOLWghtState *st, // i/o : State struct + vadState *vadSt, // i/o : VAD state struct/ + Word16 signal[], // i : signal used to compute the open loop pitch + // signal[-pit_max] to signal[-1] should be known + Word16 pit_min, // i : minimum pitch lag + Word16 pit_max, // i : maximum pitch lag + Word16 L_frame, // i : length of frame to compute pitch + Word16 old_lags[], // i : history with old stored Cl lags + Word16 ol_gain_flg[], // i : OL gain flag + Word16 idx, // i : index + Flag dtx // i : dtx flag; use dtx=1, do not use dtx=0 + ) +{ + Word16 i; + Word16 max1; + Word16 p_max1; + Word32 t0; +#ifndef VAD2 + Word16 corr_hp_max; +#endif + Word32 corr[PIT_MAX+1], *corr_ptr; + + // Scaled signal + Word16 scaled_signal[PIT_MAX + L_FRAME]; + Word16 *scal_sig; + + scal_sig = &scaled_signal[pit_max]; + + t0 = 0L; + for (i = -pit_max; i < L_frame; i++) + { + t0 = L_mac (t0, signal[i], signal[i]); + } + // + // Scaling of input signal + // + // if Overflow -> scal_sig[i] = signal[i]>>2 + // else if t0 < 1^22 -> scal_sig[i] = signal[i]<<2 + // else -> scal_sig[i] = signal[i] + + // + // Verification for risk of overflow. + // + + // Test for overflow + if (L_sub (t0, MAX_32) == 0L) + { + for (i = -pit_max; i < L_frame; i++) + { + scal_sig[i] = shr (signal[i], 3); + } + } + else if (L_sub (t0, (Word32) 1048576L) < (Word32) 0) + { + for (i = -pit_max; i < L_frame; i++) + { + scal_sig[i] = shl (signal[i], 3); + } + } + else + { + for (i = -pit_max; i < L_frame; i++) + { + scal_sig[i] = signal[i]; + } + } + + // calculate all coreelations of scal_sig, from pit_min to pit_max + corr_ptr = &corr[pit_max]; + comp_corr (scal_sig, L_frame, pit_max, pit_min, corr_ptr); + + p_max1 = Lag_max (vadSt, corr_ptr, scal_sig, L_frame, pit_max, pit_min, + st->old_T0_med, &max1, st->wght_flg, &ol_gain_flg[idx], + dtx); + + if (ol_gain_flg[idx] > 0) + { + // Calculate 5-point median of previous lag + for (i = 4; i > 0; i--) // Shift buffer + { + old_lags[i] = old_lags[i-1]; + } + old_lags[0] = p_max1; + st->old_T0_med = gmed_n (old_lags, 5); + st->ada_w = 32767; // Q15 = 1.0 + } + else + { + st->old_T0_med = p_max1; + st->ada_w = mult(st->ada_w, 29491); // = ada_w = ada_w * 0.9 + } + + if (sub(st->ada_w, 9830) < 0) // ada_w - 0.3 + { + st->wght_flg = 0; + } + else + { + st->wght_flg = 1; + } + +#ifndef VAD2 + if (dtx) + { // no test() call since this if is only in simulation env + if (sub(idx, 1) == 0) + { + // calculate max high-passed filtered correlation of all lags + hp_max (corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max); + + // update complex background detector + vad_complex_detection_update(vadSt, corr_hp_max); + } + } +#endif + + return (p_max1); +} + +------------------------------------------------------------------------------ + 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 Pitch_ol_wgh( /* o : open loop pitch lag */ + pitchOLWghtState *st, /* i/o : State struct */ + vadState *vadSt, /* i/o : VAD state struct */ + Word16 signal[], /* i : signal used to compute the open loop pitch */ + /* signal[-pit_max] to signal[-1] should be known */ + Word16 pit_min, /* i : minimum pitch lag */ + Word16 pit_max, /* i : maximum pitch lag */ + Word16 L_frame, /* i : length of frame to compute pitch */ + Word16 old_lags[], /* i : history with old stored Cl lags */ + Word16 ol_gain_flg[], /* i : OL gain flag */ + Word16 idx, /* i : index */ + Flag dtx, /* i : dtx flag; use dtx=1, do not use dtx=0 */ + Flag *pOverflow /* o : overflow flag */ +) +{ + Word16 i; + Word16 max1; + Word16 p_max1; + Word32 t0; +#ifndef VAD2 + Word16 corr_hp_max; +#endif + Word32 corr[PIT_MAX+1], *corr_ptr; + + /* Scaled signal */ + Word16 scaled_signal[PIT_MAX + L_FRAME]; + Word16 *scal_sig; + + scal_sig = &scaled_signal[pit_max]; + + t0 = 0L; + for (i = -pit_max; i < L_frame; i++) + { + t0 = L_mac(t0, signal[i], signal[i], pOverflow); + } + /*--------------------------------------------------------* + * Scaling of input signal. * + * * + * if Overflow -> scal_sig[i] = signal[i]>>2 * + * else if t0 < 1^22 -> scal_sig[i] = signal[i]<<2 * + * else -> scal_sig[i] = signal[i] * + *--------------------------------------------------------*/ + + /*--------------------------------------------------------* + * Verification for risk of overflow. * + *--------------------------------------------------------*/ + + /* Test for overflow */ + if (L_sub(t0, MAX_32, pOverflow) == 0L) + { + for (i = -pit_max; i < L_frame; i++) + { + scal_sig[i] = shr(signal[i], 3, pOverflow); + } + } + else if (L_sub(t0, (Word32) 1048576L, pOverflow) < (Word32) 0) + { + for (i = -pit_max; i < L_frame; i++) + { + scal_sig[i] = shl(signal[i], 3, pOverflow); + } + } + else + { + for (i = -pit_max; i < L_frame; i++) + { + scal_sig[i] = signal[i]; + } + } + + /* calculate all coreelations of scal_sig, from pit_min to pit_max */ + corr_ptr = &corr[pit_max]; + comp_corr(scal_sig, L_frame, pit_max, pit_min, corr_ptr); + + p_max1 = Lag_max(vadSt, corr_ptr, scal_sig, L_frame, pit_max, pit_min, + st->old_T0_med, &max1, st->wght_flg, &ol_gain_flg[idx], + dtx, pOverflow); + + if (ol_gain_flg[idx] > 0) + { + /* Calculate 5-point median of previous lags */ + for (i = 4; i > 0; i--) /* Shift buffer */ + { + old_lags[i] = old_lags[i-1]; + } + old_lags[0] = p_max1; + st->old_T0_med = gmed_n(old_lags, 5); + st->ada_w = 32767; /* Q15 = 1.0 */ + } + else + { + st->old_T0_med = p_max1; + /* = ada_w = ada_w * 0.9 */ + st->ada_w = mult(st->ada_w, 29491, pOverflow); + } + + if (sub(st->ada_w, 9830, pOverflow) < 0) /* ada_w - 0.3 */ + { + st->wght_flg = 0; + } + else + { + st->wght_flg = 1; + } + +#ifndef VAD2 + if (dtx) + { /* no test() call since this if is only in simulation env */ + if (sub(idx, 1, pOverflow) == 0) + { + /* calculate max high-passed filtered correlation of all lags */ + hp_max(corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max, pOverflow); + + /* update complex background detector */ + vad_complex_detection_update(vadSt, corr_hp_max); + } + } +#endif + + return (p_max1); +} + +/*---------------------------------------------------------------------------- +; End Function: Pitch_ol_wgh +----------------------------------------------------------------------------*/ + + + + + |