3 Computational details
06.323GPPTSVoice Activity Detection (VAD)
In the next paragraphs, the detailed description of the VAD algorithm follows the preceding high level description. This detailed description is divided in ten clauses related to the blocks of figure 2.1 (except periodicity updating) in the high level description of the VAD algorithm.
Those clauses are:
1) adaptive filtering and energy computation;
2) ACF averaging;
3) predictor values computation;
4) spectral comparison;
5) periodicity detection;
6) threshold adaptation;
7) VAD decision;
8) VAD hangover addition;
9) periodicity updating;
10) information tone detection.
The VAD algorithm takes as input the following variables of the RPE‑LTP encoder (see the detailed description of the RPE‑LTP encoder GSM 06.10):
‑ L_ACF[0..8], auto‑correlation function (GSM 06.10/4.2.4);
‑ scalauto, scaling factor to compute the L_ACF[0..8] (GSM 06.10/4.2.4);
‑ Nc, LTP lag (one for each sub‑segment, GSM 06.10/4.2.11);
‑ sof, offset compensated signal frame (GSM 06.10/4.2.2).
So four Nc values are needed for the VAD algorithm.
The VAD computation can start as soon as the L_ACF[0..8] and scalauto variables are known. This means that the VAD computation can take place after part 4.2.4 of GSM 06.10 (Auto‑correlation) of the LPC analysis clause of the RPE‑LTP encoder. This scheme will reduce the delay to yield the VAD information. The periodicity updating (included in clause 2.2.5) and information tone detection, are done after the processing of the current speech encoder frame.
All the arithmetic operations and names of the variables follow the RPE‑LTP detailed description. To increase the precision within the fixed point implementation, a pseudo‑floating point representation of some variables is used. This stands for the following variables (and related constants) of the VAD algorithm:
pvad: Energy of filtered signal;
thvad: Threshold of the VAD decision;
acf0: Energy of input signal.
For the representation of these variables, two integers (16 bits) are needed:
‑ one for the exponent (e_pvad, e_thvad, e_acf0);
‑ one for the mantissa (m_pvad, m_thvad, m_acf0).
The value e_pvad represents the lowest power of 2 just greater or equal to the actual value of pvad and the m_pvad value represents a integer which is always greater or equal to 16384 (normalized mantissa). It means that the pvad value is equal to:
This scheme guarantees a large dynamic range for the pvad value and always keeps a precision of 16 bits. All the comparisons are easy to make by comparing the exponents of two variables and the VAD algorithm needs only one pseudo‑floating point addition. All the computations related to the pseudo‑floating point variables require very simple 16 or 32 bits arithmetic operations defined in the detailed description of the RPE‑LTP encoder. This pseudo‑floating point arithmetic is only used in clauses 3.1 and 3.6.
Table 3.1 gives a list of all the variables of the VAD algorithm that must be initialized in the reset procedure and kept in memory for processing the subsequent frame of the RPE‑ LTP encoder. The types (16 or 32 bits) and initial values of all these variables are clearly indicated and their related clause is also mentioned. The bit exact implementation uses other temporary variables that are introduced in the detailed description whenever it is needed.
Table 3.1: Initial values for variables to be stored in memory
Names of variables: 
type (# of bits): 
Initialization: 
Subclause: 
Adaptive filter coefficients: 

rvad[0] 
16 
24 576 
3.1, 3.6 
rvad[1] 
16 
‑16 384 
3.1, 3.6 
rvad[2] 
16 
4 096 
3.1, 3.6 
rvad[3..8] 
16 
0 
3.1, 3.6 
Scaling factor of ravd[0..8]: 

normrvad 
16 
7 
3.1, 3.6 
Delay line of the auto‑correlation coefficients: 

L_sacf[0..26] 
32 
0 
3.2 
L_sav0[0..35] 
32 
0 
3.2 
Pointers on the delay lines: 

pt_sacf 
16 
0 
3.2 
pt_sav0 
16 
0 
3.2 
Distance measure: 

L_lastdm 
32 
0 
3.4 
Periodicity counters: 

oldlagcount 
16 
0 
3.5, 3.9 
veryoldlagcount 
16 
0 
3.5, 3.9 
Adaptive threshold: 

e_thvad (exponent) 
16 
20 
3.6 
m_thvad (mantissa) 
16 
31 250 
3.6 
Counter for adaptation: 

adaptcount 
16 
0 
3.6 
Hangover flags: 

burstcount 
16 
0 
3.8 
hangcount 
16 
‑1 
3.8 
LTP lag memory: 

oldlag 
16 
40 
3.9 
Tone Detection 

tone 
16 
0 
3.10 
3.1 Adaptive filtering and energy computation
This clause computes the e_pvad and m_pvad variables which represent the pvad value. It needs the L_ACF[0..8] and scalauto variables of the RPE‑LTP algorithm and the rvad[0..8] and normrvad variables produced by clause 3.6 of the VAD algorithm. It also computes a floating point representation of L_ACF[0] (e_acf0 and m_acf0) used in clause 3.6.
Test if L_ACF[0] is equal to 0:
IF ( scalauto < 0 ) THEN scalvad = 0;
ELSE scalvad = scalauto; / keep scalvad for use in clause 3.2 /
IF ( L_ACF[0] == 0 ) THEN
 e_pvad = ‑32768;
 m_pvad = 0;
 e_acf0 = ‑32768;
 m_acf0 = 0;
 EXIT /continue with clause 3.2/
Re‑normalization of the L_ACF[0..8]:
normacf = norm( L_ACF[0] );
 FOR i = 0 to 8:
 sacf[i] = ( L_ACF[i] << normacf ) >> 19;
 NEXT i:
Computation of e_acf0 and m_acf0:
e_acf0 = add( 32, (scalvad << 1 ) );
e_acf0 = sub( e_acf0, normacf);
m_acf0 = sacf[0] << 3;
Computation of e_pvad and m_pvad:
e_pvad = add( e_acf0, 14 );
e_pvad = sub( e_pvad, normrvad );
L_temp = 0;
 FOR i = 1 to 8:
 L_temp = L_add( L_temp, L_mult( sacf[i], rvad[i] ) );
 NEXT i:
L_temp = L_add( L_temp, L_mult( sacf[0], rvad[0] ) >> 1 );
IF ( L_temp <= 0 ) THEN L_temp = 1;
normprod = norm( L_temp );
e_pvad = sub( e_pvad, normprod );
m_pvad = ( L_temp << normprod ) >> 16;
3.2 ACF averaging
This clause uses the L_ACF[0..8] and the scalvad variables to compute the array L_av0[0..8] and L_av1[0..8] used in clause 3.3 and 3.4.
Computation of the scaling factor:
scal = sub( 10, (scalvad << 1) );
Computation of the arrays L_av0[0..8] and L_av1[0..8]:
 FOR i = 0 to 8:
 L_temp = L_ACF[i] >> scal;
 L_av0[i] = L_add( L_sacf[i], L_temp );
 L_av0[i] = L_add( L_sacf[i+9], L_av0[i] );
 L_av0[i] = L_add( L_sacf[i+18], L_av0[i] );
 L_sacf[ pt_sacf + i ] = L_temp;
 L_av1[i] = L_sav0[ pt_sav0 + i ];
 L_sav0[ pt_sav0 + i] = L_av0[i];
 NEXT i:
Update of the array pointers:
IF ( pt_sacf == 18 ) THEN pt_sacf = 0;
ELSE pt_sacf = add( pt_sacf, 9);
IF ( pt_sav0 == 27 ) THEN pt_sav0 = 0;
ELSE pt_sav0 = add( pt_sav0, 9);
3.3 Predictor values computation
This clause computes the array rav1[0..8] needed for the spectral comparison and the threshold adaptation. It uses the L_av1[0..8] computed in clause 3.2, and is divided in the three following clauses:
‑ Schur recursion to compute reflection coefficients.
‑ Step up procedure to obtain the aav1[0..8].
‑ Computation of the rav1[0..8].
3.3.1 Schur recursion to compute reflection coefficients
This clause is identical to the one used in the RPE‑LTP algorithm. The array vpar[1..8] is computed with the array L_av1[0..8] as an input.
Schur recursion with 16 bits arithmetic:
IF( L_av1[0] == 0 ) THEN
== FOR i = 1 to 8:
 vpar[i] = 0;
== NEXT i:
 EXIT; /continue with clause 3.3.2/
temp = norm( L_av1[0] );
== FOR k=0 to 8:
 sacf[k] = ( L_av1[k] << temp ) >> 16;
== NEXT k:
Initialize array P[..] and K[..] for the recursion:
== FOR i=1 to 7:
 K[9‑i] = sacf[i];
== NEXT i:
== FOR i=0 to 8:
 P[i] = sacf[i];
== NEXT i:
Compute reflection coefficients:
== FOR n=1 to 8:
 IF( P[0] < abs( P[1] ) ) THEN
 == FOR i = n to 8:
  vpar[i] = 0;
 == NEXT i:
  EXIT; /continue with
  clause 3.3.2/
 vpar[n] = div( abs( P[1] ), P[0] );
 IF ( P[1] > 0 ) THEN vpar[n] = sub( 0, vpar[n] );
 IF ( n == 8 ) THEN EXIT; /continue with clause 3.3.2/

 Schur recursion:

 P[0] = add( P[0], mult_r( P[1], vpar[n] ) );
==== FOR m=1 to 8‑n:
 P[m] = add( P[m+1], mult_r( K[9‑m], vpar[n] ) );
 K[9‑m] = add( K[9‑m], mult_r( P[m+1], vpar[n] ) );
==== NEXT m:

== NEXT n:
3.3.2 Step‑up procedure to obtain the aav1[0..8]
Initialization of the step‑up recursion:
L_coef[0] = 16384 << 15;
L_coef[1] = vpar[1] << 14;
Loop on the LPC analysis order:
= FOR m = 2 to 8:
== FOR i = 1 to m‑1:
== temp = L_coef[m‑i] >> 16; / takes the msb /
== L_work[i] = L_add( L_coef[i], L_mult( vpar[m], temp ) );
== NEXT i
=
== FOR i = 1 to m‑1:
== L_coef[i] = L_work[i];
== NEXT i
=
= L_coef[m] = vpar[m] << 14;
= NEXT m:
Keep the aav1[0..8] on 13 bits for next clause:
 FOR i = 0 to 8:
 aav1[i] = L_coef[i] >> 19;
 NEXT i:
3.3.3 Computation of the rav1[0..8]
= FOR i= 0 to 8:
= L_work[i] = 0;
== FOR k = 0 to 8‑i:
== L_work[i] = L_add( L_work[i], L_mult( aav1[k], aav1[k+i] ) );
== NEXT k:
= NEXT i:
IF ( L_work[0] == 0 ) THEN normrav1 =0;
ELSE normrav1 = norm( L_work[0] );
= FOR i= 0 to 8:
= rav1[i] = ( L_work[i] << normrav1 ) >> 16;
= NEXT i:
Keep the normrav1 for use in clause 3.4 and 3.6.
3.4 Spectral comparison
This clause computes the variable stat needed for the threshold adaptation. It uses the array L_av0[0..8] computed in clause 3.2 and the array rav1[0..8] computed in clause 3.3.3.
Re‑normalize L_av0[0..8]:
IF ( L_av0[0] == 0 ) THEN
 FOR i = 0 to 8:
 sav0[i] = 4095;
 NEXT i:
ELSE
 shift = norm( L_av0[0] );
= FOR i = 0 to 8:
= sav0[i] = ( L_av0[i] << shift‑3 ) >> 16;
= NEXT i:
Compute partial of dm:
L_ p = 0;
= FOR i = 1 to 8:
= L_ p = L_add( L_ p, L_mult( rav1[i], sav0[i] ) );
= NEXT i:
Compute the division of partial by sav0[0]:
IF ( L_ p < 0 ) THEN L_temp = L_sub( 0, L_ p );
ELSE L_temp = L_ p;
IF ( L_temp == 0 ) THEN
 L_dm = 0;
 shift = 0;
ELSE
 sav0[0] = sav0[0] << 3;
 shift = norm( L_temp );
 temp = ( L_temp << shift ) >> 16;
 IF ( sav0[0] >= temp ) THEN
  divshift = 0;
  temp = div( temp, sav0[0] );
 ELSE
  divshift = 1;
  temp = sub( temp, sav0[0] );
  temp = div( temp, sav0[0] );

 IF( divshift == 1 ) THEN L_dm = 32768;
 ELSE L_dm = 0;

 L_dm = L_add( L_dm, temp) << 1;
 IF( L_ p < 0 ) THEN L_dm = L_sub( 0, L_dm);
Re‑normalization and final computation of L_dm:
L_dm = ( L_dm << 14 );
L_dm = L_dm >> shift;
L_dm = L_add( L_dm, ( rav1[0] << 11 ) );
L_dm = L_dm >> normrav1;
Compute the difference and save L_dm:
L_temp = L_sub( L_dm, L_lastdm );
L_lastdm = L_dm;
IF ( L_temp < 0 ) THEN L_temp = L_sub( 0, L_temp );
L_temp = L_sub( L_temp, 3277 );
Evaluation of the stat flag:
IF ( L_temp < 0 ) THEN stat = 1;
ELSE stat = 0;
3.5 Periodicity detection
This clause just sets the ptch flag needed for the threshold adaptation.
temp = add( oldlagcount, veryoldlagcount );
IF ( temp >= 4 ) THEN ptch = 1;
ELSE ptch = 0;
3.6 Threshold adaptation
This clause uses the variables e_pvad, m_pvad, e_acf0 and m_acf0 computed in clause 3.1. It also uses the flags stat (see clause 3.4) and ptch (see clause 3.5). It follows the flowchart represented on figure 2.2.
Some constants, represented by a floating point format, are needed and a symbolic name (in capital letter) for their exponent and mantissa is used; table 3.2 lists all these constants with the symbolic names associated and their numerical constant values.
Table 3.2: List of constants
Constant 
Exponent 
Mantissa 
pth 
E_PTH = 19 
M_PTH = 18 750 
NOTE: Floating point representation of constants used in clause 3.6:
pth = 2(E_PTH)x(M_PTH/32768). margin = 2(E_MARGIN)x(M_MARGIN/32768). plev = 2(E_PLEV)x(M_PLEV/32768).
Test if acf0 < pth; if yes set thvad to plev:
comp = 0;
IF ( e_acf0 < E_PTH ) THEN comp = 1;
IF ( e_acf0 == E_PTH ) THEN IF ( m_acf0 < M_PTH ) THEN comp =1;
IF ( comp == 1 ) THEN
 e_thvad = E_PLEV;
 m_thvad = M_PLEV;
 EXIT; /continue with clause 3.7/
Test if an adaptation is needed:
comp = 0;
IF ( ptch == 1 ) THEN comp = 1;
IF ( stat == 0 ) THEN comp = 1;
IF ( tone == 1 ) THEN comp = 1;
IF ( comp == 1 ) THEN
 adaptcount = 0;
 EXIT; /continue with clause 3.7/
Incrementation of adaptcount:
adaptcount = add( adaptcount, 1 );
IF ( adaptcount <= 8 ) THEN EXIT; /continue with clause 3.7/
Computation of thvad‑(thvad/dec):
m_thvad = sub( m_thvad, (m_thvad >> 5 ) );
IF ( m_thvad < 16384) THEN
 m_thvad = m_thvad << 1;
 e_thvad = sub( e_thvad, 1 );
Computation of pvad*fac:
L_temp = L_add( m_pvad, m_pvad );
L_temp = L_add( L_temp, m_pvad );
L_temp = L_temp >> 1;
e_temp = add( e_pvad, 1 );
IF ( L_temp > 32767 ) THEN
 L_temp = L_temp >> 1;
 e_temp = add( e_temp, 1 );
m_temp = L_temp;
Test if thvad < pvad*fac:
comp = 0;
IF ( e_thvad < e_temp) THEN comp = 1;
IF (e_thvad == e_temp) THEN IF (m_thvad < m_temp) THEN comp =1;
Computation of minimum (thvad+(thvad/inc), pvad*fac) if comp = 1:
IF ( comp == 1 ) THEN
 Compute thvad +(thvad/inc).
 L_temp = L_add( m_thvad, (m_thvad >> 4 ) );
 IF ( L_temp > 32767 ) THEN
  m_thvad = L_temp >> 1;
  e_thvad = add( e_thvad,1 );
 ELSE m_thvad = L_temp;
 comp2 = 0;
 IF ( e_temp < e_thvad) THEN comp2 = 1;
 IF (e_temp == e__hvad) THEN IF (m_temp<m_thvad) THEN comp2 = 1;
 IF ( comp2 == 1 ) THEN
  e_thvad = e_temp;
  m_thvad = m_temp;
Computation of pvad + margin:
IF ( e_pvad == E_MARGIN ) THEN
 L_temp = L_add(m_pvad, M_MARGIN);
 m_temp = L_temp >> 1;
 e_temp = add( e_pvad, 1 );
ELSE
 IF ( e_pvad > E_MARGIN ) THEN
  temp = sub( e_pvad, E_MARGIN );
  temp = M_MARGIN >> temp;
  L_temp = L_add( m_pvad, temp );
  IF ( L_temp > 32767) THEN
   e_temp = add( e_pvad, 1 );
   m_temp = L_temp >> 1;
  ELSE
   e_temp = e_pvad;
   m_temp = L_temp;
 ELSE
  temp = sub( E_MARGIN, e_pvad );
  temp = m_pvad >> temp;
  L_temp = L_add( M_MARGIN, temp );
  IF (L_temp > 32767) THEN
   e_temp = add( E_MARGIN, 1);
   m_temp = L_temp >> 1;
  ELSE
   e_temp = E_MARGIN;
   m_temp = L_temp;
Test if thvad > pvad + margin:
comp = 0;
IF ( e_thvad > e_temp) THEN comp = 1;
IF (e_thvad == e_temp) THEN IF (m_thvad > m_temp) THEN comp =1;
IF ( comp == 1 ) THEN
 e_thvad = e_temp;
 m_thvad = m_temp;
Initialize new rvad[0..8] in memory:
normrvad = normrav1;
= FOR i = 0 to 8:
= rvad[i] = rav1[i];
= NEXT i:
Set adaptcount to adp + 1:
adaptcount = 9;
3.7 VAD decision
This clause only outputs the result of the comparison between pvad and thvad using the pseudo‑floating point representation of thvad and pvad. The values e_pvad and m_pvad are computed in clause 3.1 and the values e_thvad and m_thvad are computed in clause 3.6.
vvad = 0;
IF (e_pvad > e_thvad) THEN vvad = 1;
IF (e_pvad == e_thvad) THEN IF (m_pvad > m_thvad) THEN vvad =1;
3.8 VAD hangover addition
This clause finally sets the vad decision for the current frame to be processed.
IF ( vvad == 1 ) THEN burstcount = add( burstcount, 1 );
ELSE burstcount = 0;
IF ( burstcount >= 3 ) THEN
 hangcount = 5;
 burstcount = 3;
vad = vvad;
IF ( hangcount >= 0 ) THEN
 vad = 1;
 hangcount = sub( hangcount, 1 );
3.9 Periodicity updating
This clause must be delayed until the LTP lags are computed by the RPE‑LTP algorithm. The LTP lags called Nc in the speech encoder are renamed lags[0..3] (index 0 for the first sub‑ segment of the frame, 1 for the second and so on).
Loop on sub‑segments for the frame:
lagcount = 0;
= FOR i = 0 to 3:
= Search the maximum and minimum of consecutive lags.
= IF ( oldlag > lags[i] ) THEN
=  minlag = lags[i];
=  maxlag = oldlag;
= ELSE
=  minlag = oldlag;
=  maxlag = lags[i] ;
=
= Compute smallag (modulo operation not defined ):
=
= smallag = maxlag;
==  FOR j = 0 to 2:
==  IF (smallag >= minlag) THEN smallag =sub( smallag, minlag);
==  NEXT j;
=
= Minimum of smallag and minlag ‑ smallag:
=
= temp = sub( minlag, smallag );
= IF ( temp < smallag ) THEN smallag = temp;
= IF ( smallag < 2 ) THEN lagcount = add( lagcount, 1 );
= Save the current LTP lag.
= oldlag = lags[i];
= NEXT i:
Update the veryoldlagcount and oldlagcount:
veryoldlagcount = oldlagcount;
oldlagcount = lagcount;
3.10 Tone detection
This clause computes the tone variable needed for the threshold adaptation. Tone is only calculated for the VAD in the downlink. In the uplink VAD tone=0.
To reduce delay, this clause should be calculated after the processing of the current speech encoder frame.
3.10.1 Windowing
This clause applies a Hanning window to the input frame sof[0..159] to form the output frame sofh[0..159]. The input frame is the current offset compensated signal frame calculated in the RPE‑LTP codec. The array of constants hann[i] is defined in table 3.2.
Multiply signal frame by Hanning window:
== FOR i = 0 to 79:
 sofh[i] = mult_r( sof[i], hann[i] );
 sofh[159‑i] = mult_r( sof[159‑i], hann[i] );
== NEXT i;
3.10.2 Auto‑correlation
This clause computes the auto‑correlation vector L_acfh[0..5] from the windowed input frame sofh[0..159]. The input frame must be scaled in order to avoid an overflow situation. This clause is identical to the one used in the RPE‑LTP algorithm, with the exception that only five auto‑correlation values are calculated.
Dynamic scaling of the array sofh[0..159]:
Search for the maximum:
smax = 0;
== FOR k = 0 to 159:
 temp = abs( sofh[k] );
 IF ( temp > smax ) THEN smax = temp;
== NEXT k;
Computation of the scaling factor:
IF ( smax == 0 ) THEN scalauto = 0;
ELSE scalauto = sub( 4, norm( smax << 16));
Scaling of the array sofh[0..159]:
IF ( scalauto > 0 ) THEN
 temp = 16384 >> sub( scalauto,1);
== FOR k = 0 to 159:
 sofh[k] = mult_r( sofh[k], temp);
== NEXT k:
Compute the L_ACF[..]:
== FOR k=0 to 4:
 L_acfh[k] = 0;
==== FOR i=k to 159:
 L_temp = L_mult( sofh[i], sofh[i‑k] );
 L_acfh[k] = L_add( L_acfh[k], L_temp );
==== NEXT i:
== NEXT k:
3.10.3 Computation of the reflection coefficients
This clause calculates the reflection coefficients rc[1..4] from the input array L_acfh[0..4]. This procedure is identical to the one in clause 3.3.1 and the RPE‑LTP codec, with the exception that only four reflection coefficients are calculated.
Schur recursion with 16 bits arithmetic:
IF( L_acfh[0] == 0 ) THEN
== FOR i = 1 to 4:
 rc[i] = 0;
== NEXT i:
 EXIT; /continue with clause 3.10.4/
temp = norm( L_acfh[0] );
== FOR k=0 to 4:
 sacf[k] = ( L_acfh[k] << temp ) >> 16;
== NEXT k:
Initialize array P[..] and K[..] for the recursion:
== FOR i=1 to 3:
 K[5‑i] = sacf[i];
== NEXT i:
== FOR i=0 to 4:
 P[i] = sacf[i];
== NEXT i:
Compute reflection coefficients:
== FOR n=1 to 4:
 IF( P[0] < abs( P[1] ) ) THEN
 == FOR i = n to 4:
  rc[i] = 0;
 == NEXT i:
  EXIT; /continue with clause 3.10.4/
 rc[n] = div( abs( P[1] ), P[0] );
 IF ( P[1] > 0 ) THEN rc[n] = sub( 0, rc[n] );
 IF ( n == 4 ) THEN EXIT; /continue with clause 3.10.4/

Schur recursion:
 P[0] = add( P[0], mult_r( P[1], rc[n] ) );
==== FOR m=1 to 4‑n:
 P[m] = add( P[m+1], mult_r( K[5‑m], rc[n] ) );
 K[5‑m] = add( K[5‑m], mult_r( P[m+1], rc[n] ) );
==== NEXT m:

== NEXT n:
3.10.4 Filter coefficient calculation
This clause calculates the direct form filter coefficients a[1..2] from the reflection coefficients rc[1..4].
Step‑up procedure to obtain the a[1..2]:
temp = rc[1] >> 2;
a[1] = add( temp, mult_r( rc[2], temp ) );
a[2] = rc[2] >> 2;
3.10.5 Pole Frequency Test
This clause uses the direct form filter coefficients a[1..2] to determine the pole frequency of the second order LPC analysis. If the pole frequency is less than 385 Hz tone is set to 0 and clause 3 terminates.
L_den = L_mult ( a[1], a[1] );
L_temp = a[2] << 16;
L_num = L_sub ( L_temp, L_den );
If pole is not complex then exit:
IF ( L_num <= 0 ) THEN
 tone = 0;
 EXIT; /clause 3 complete/
If pole frequency is less than 385 Hz then exit:
IF ( a[1] < 0) THEN
 temp = L_den >> 16;
 L_den = L_mult ( temp, 3189 );
 L_temp = L_sub ( L_num, L_den );
 IF ( L_temp < 0 ) THEN
 tone = 0;
 EXIT; /clause 3 complete/
3.10.6 Prediction gain test
This clause uses the reflection coefficients rc[1..4] to calculate the prediction gain. If the prediction gain is greater than 13,5 dB then tone is set to 1 otherwise tone is set to 0.
Calculate normalized prediction error:
prederr = 32767;
== FOR i=1 to 4
 temp = mult ( rc[i], rc[i] );
 temp = sub ( 32767, temp);
 prederr = mult( prederr, temp );
== NEXT i;
Test if prediction error is smaller than threshold:
temp = sub ( prederr, 1464 );
IF ( temp < 0 ) THEN tone = 1;
ELSE tone = 0;
Table 3.2: Values of the Hanning window array hann[i]
i 
hann 
i 
hann 
i 
hann 
i 
hann 
0 
0 
20 
4856 
40 
16545 
60 
28139 
1 
12 
21 
5325 
41 
17192 
61 
28581 
2 
51 
22 
5811 
42 
17838 
62 
29003 
3 
114 
23 
6314 
43 
18482 
63 
29406 
4 
204 
24 
6832 
44 
19122 
64 
29789 
5 
318 
25 
7365 
45 
19758 
65 
30151 
6 
458 
26 
7913 
46 
20389 
66 
30491 
7 
622 
27 
8473 
47 
21014 
67 
30809 
8 
811 
28 
9046 
48 
21631 
68 
31105 
9 
1025 
29 
9631 
49 
22240 
69 
31377 
10 
1262 
30 
10226 
50 
22840 
70 
31626 
11 
1523 
31 
10831 
51 
23430 
71 
31852 
12 
1807 
32 
11444 
52 
24009 
72 
32053 
13 
2114 
33 
12065 
53 
24575 
73 
32230 
14 
2444 
34 
12693 
54 
25130 
74 
32382 
15 
2795 
35 
13326 
55 
25670 
75 
32509 
16 
3167 
36 
13964 
56 
26196 
76 
32611 
17 
3560 
37 
14607 
57 
26707 
77 
32688 
18 
3972 
38 
15251 
58 
27201 
78 
32739 
19 
4405 
39 
15898 
59 
27679 
79 
32764 