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);
}
/*************************************************************************
*
* FUNCTION: Pitch_ol
*
* PURPOSE: Compute the open loop pitch lag.
*
* DESCRIPTION:
* The open-loop pitch lag is determined based on the perceptually
* weighted speech signal. This is done in the following steps:
* - find three maxima of the correlation <sw[n],sw[n-T]>,
* dividing the search range into three parts:
* pit_min ... 2*pit_min-1
* 2*pit_min ... 4*pit_min-1
* 4*pit_min ... pit_max
* - divide each maximum by <sw[n-t], sw[n-t]> where t is the delay at
* that maximum correlation.
* - select the delay of maximum normalized correlation (among the
* three candidates) while favoring the lower delay ranges.
*
*************************************************************************/
Word16 Pitch_ol ( /* o : open loop pitch lag */
vadState *vadSt, /* i/o : VAD state struct */
enum Mode mode, /* i : coder mode */
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 idx, /* i : frame index */
Flag dtx /* i : dtx flag; use dtx=1, do not use dtx=0 */
)
{
Word16 i, j;
Word16 max1, max2, max3;
Word16 p_max1, p_max2, p_max3;
Word16 scal_flag = 0;
Word32 t0;
#ifdef VAD2
Word32 r01, r02, r03;
Word32 rmax1, rmax2, rmax3;
#else
Word16 corr_hp_max;
#endif
Word32 corr[PIT_MAX+1], *corr_ptr;
/* Scaled signal */
Word16 scaled_signal[L_FRAME + PIT_MAX];
Word16 *scal_sig, scal_fac;
#ifndef VAD2
if (dtx)
{ /* no test() call since this if is only in simulation env */
/* update tone detection */
test(); test();
if ((sub(mode, MR475) == 0) || (sub(mode, MR515) == 0))
{
vad_tone_detection_update (vadSt, 1);
}
else
{
vad_tone_detection_update (vadSt, 0);
}
}
#endif
scal_sig = &scaled_signal[pit_max]; move16 ();
t0 = 0L; move32 ();
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]>>3 *
* else if t0 < 1^20 -> scal_sig[i] = signal[i]<<3 *
* else -> scal_sig[i] = signal[i] *
*--------------------------------------------------------*/
/*--------------------------------------------------------*
* Verification for risk of overflow. *
*--------------------------------------------------------*/
test ();
if (L_sub (t0, MAX_32) == 0L) /* Test for overflow */
{
for (i = -pit_max; i < L_frame; i++)
{
scal_sig[i] = shr (signal[i], 3); move16 ();
}
scal_fac = 3; move16 ();
}
else if (L_sub (t0, (Word32) 1048576L) < (Word32) 0)
/* if (t0 < 2^20) */
{
test ();
for (i = -pit_max; i < L_frame; i++)
{
scal_sig[i] = shl (signal[i], 3); move16 ();
}
scal_fac = -3; move16 ();
}
else
{
test ();
for (i = -pit_max; i < L_frame; i++)
{
scal_sig[i] = signal[i]; move16 ();
}
scal_fac = 0; move16 ();
}
/* calculate all coreelations of scal_sig, from pit_min to pit_max */
corr_ptr = &corr[pit_max]; move32 ();
comp_corr (scal_sig, L_frame, pit_max, pit_min, corr_ptr);
/*--------------------------------------------------------------------*
* The pitch lag search is divided in three sections. *
* Each section cannot have a pitch multiple. *
* We find a maximum for each section. *
* We compare the maximum of each section by favoring small lags. *
* *
* First section: lag delay = pit_max downto 4*pit_min *
* Second section: lag delay = 4*pit_min-1 downto 2*pit_min *
* Third section: lag delay = 2*pit_min-1 downto pit_min *
*--------------------------------------------------------------------*/
/* mode dependent scaling in Lag_max */
test ();
if (sub(mode, MR122) == 0)
{
scal_flag = 1; move16 ();
}
else
{
scal_flag = 0; move16 ();
}
#ifdef VAD2
j = shl (pit_min, 2);
p_max1 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
pit_max, j, &max1, &rmax1, &r01, dtx);
move16 (); /* function result */
i = sub (j, 1);
j = shl (pit_min, 1);
p_max2 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
i, j, &max2, &rmax2, &r02, dtx);
move16 (); /* function result */
i = sub (j, 1);
p_max3 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
i, pit_min, &max3, &rmax3, &r03, dtx);
move16 (); /* function result */
#else
j = shl (pit_min, 2);
p_max1 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
pit_max, j, &max1, dtx); move16 (); /* function result */
i = sub (j, 1);
j = shl (pit_min, 1);
p_max2 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
i, j, &max2, dtx); move16 (); /* function result */
i = sub (j, 1);
p_max3 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
i, pit_min, &max3, dtx); move16 (); /* function result */
if (dtx)
{ /* no test() call since this if is only in simulation env */
test ();
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
/*--------------------------------------------------------------------*
* Compare the 3 sections maximum, and favor small lag. *
*--------------------------------------------------------------------*/
test ();
if (sub (mult (max1, THRESHOLD), max2) < 0)
{
max1 = max2; move16 ();
p_max1 = p_max2; move16 ();
#ifdef VAD2
if (dtx)
{
rmax1 = rmax2; move32 ();
r01 = r02; move32 ();
}
#endif
}
test ();
if (sub (mult (max1, THRESHOLD), max3) < 0)
{
p_max1 = p_max3; move16 ();
#ifdef VAD2
if (dtx)
{
rmax1 = rmax3; move32 ();
r01 = r03; move32 ();
}
#endif
}
#ifdef VAD2
if (dtx)
{
vadSt->L_Rmax = L_add(vadSt->L_Rmax, rmax1); /* Save max correlation */
vadSt->L_R0 = L_add(vadSt->L_R0, r01); /* Save max energy */
}
#endif
return (p_max1);
}