Word16 Test_Err(Word16 Lag1, Word16 Lag2,ENC_HANDLE *handle)
{
int i, i1, i2;
Word16 zone1, zone2;
Word32 Acc, Err_max;
Word16 iTest;
i2 = Lag2 + ClPitchOrd/2;
zone2 = mult( (Word16) i2, (Word16) 1092);
i1 = - SubFrLen + 1 + Lag1 - ClPitchOrd/2;
if(i1 <= 0) i1 = 1;
zone1 = mult( (Word16) i1, (Word16) 1092);
Err_max = -1L;
for(i=zone2; i>=zone1; i--) {
Acc = L_sub(handle->CodStat.Err[i], Err_max);
if(Acc > 0L) {
Err_max = handle->CodStat.Err[i];
}
}
Acc = L_sub(Err_max, ThreshErr);
if((Acc > 0L) || (handle->CodStat.SinDet < 0 ) ) {
iTest = 0;
}
else {
Acc = L_negate(Acc);
Acc = L_shr(Acc, DEC);
iTest = extract_l(Acc);
}
return(iTest);
}
/*
* The decimation-in-time complex FFT is implemented below.
* The input complex numbers are presented as real part followed by
* imaginary part for each sample. The counters are therefore
* incremented by two to access the complex valued samples.
*/
void r_fft(Word16 * farray_ptr, Flag *pOverflow)
{
Word16 ftmp1_real;
Word16 ftmp1_imag;
Word16 ftmp2_real;
Word16 ftmp2_imag;
Word32 Lftmp1_real;
Word32 Lftmp1_imag;
Word16 i;
Word16 j;
Word32 Ltmp1;
/* Perform the complex FFT */
c_fft(farray_ptr, pOverflow);
/* First, handle the DC and foldover frequencies */
ftmp1_real = *farray_ptr;
ftmp2_real = *(farray_ptr + 1);
*farray_ptr = add(ftmp1_real, ftmp2_real, pOverflow);
*(farray_ptr + 1) = sub(ftmp1_real, ftmp2_real, pOverflow);
/* Now, handle the remaining positive frequencies */
for (i = 2, j = SIZE - i; i <= SIZE_BY_TWO; i = i + 2, j = SIZE - i)
{
ftmp1_real = add(*(farray_ptr + i), *(farray_ptr + j), pOverflow);
ftmp1_imag = sub(*(farray_ptr + i + 1),
*(farray_ptr + j + 1), pOverflow);
ftmp2_real = add(*(farray_ptr + i + 1),
*(farray_ptr + j + 1), pOverflow);
ftmp2_imag = sub(*(farray_ptr + j),
*(farray_ptr + i), pOverflow);
Lftmp1_real = L_deposit_h(ftmp1_real);
Lftmp1_imag = L_deposit_h(ftmp1_imag);
Ltmp1 = L_mac(Lftmp1_real, ftmp2_real, phs_tbl[i], pOverflow);
Ltmp1 = L_msu(Ltmp1, ftmp2_imag, phs_tbl[i + 1], pOverflow);
*(farray_ptr + i) = pv_round(L_shr(Ltmp1, 1, pOverflow), pOverflow);
Ltmp1 = L_mac(Lftmp1_imag, ftmp2_imag, phs_tbl[i], pOverflow);
Ltmp1 = L_mac(Ltmp1, ftmp2_real, phs_tbl[i + 1], pOverflow);
*(farray_ptr + i + 1) = pv_round(L_shr(Ltmp1, 1, pOverflow), pOverflow);
Ltmp1 = L_mac(Lftmp1_real, ftmp2_real, phs_tbl[j], pOverflow);
Ltmp1 = L_mac(Ltmp1, ftmp2_imag, phs_tbl[j + 1], pOverflow);
*(farray_ptr + j) = pv_round(L_shr(Ltmp1, 1, pOverflow), pOverflow);
Ltmp1 = L_negate(Lftmp1_imag);
Ltmp1 = L_msu(Ltmp1, ftmp2_imag, phs_tbl[j], pOverflow);
Ltmp1 = L_mac(Ltmp1, ftmp2_real, phs_tbl[j + 1], pOverflow);
*(farray_ptr + j + 1) = pv_round(L_shr(Ltmp1, 1, pOverflow), pOverflow);
}
} /* end r_fft () */
/*
**
** Function: Calc_Exc_Rand()
**
** Description: Computation of random excitation for inactive frames:
** Adaptive codebook entry selected randomly
** Higher rate innovation pattern selected randomly
** Computes innovation gain to match curGain
**
** Links to text:
**
** Arguments:
**
** Word16 curGain current average gain to match
** Word16 *PrevExc previous/current excitation (updated)
** Word16 *DataEXc current frame excitation
** Word16 *nRandom random generator status (input/output)
**
** Outputs:
**
** Word16 *PrevExc
** Word16 *DataExc
** Word16 *nRandom
**
** Return value: None
**
*/
void Calc_Exc_Rand(Word16 curGain, Word16 *PrevExc, Word16 *DataExc,
Word16 *nRandom, LINEDEF *Line)
{
int i, i_subfr, iblk;
Word16 temp, temp2;
Word16 j;
Word16 TabPos[2*NbPulsBlk], TabSign[2*NbPulsBlk];
Word16 *ptr_TabPos, *ptr_TabSign;
Word16 *ptr1, *curExc;
Word16 sh1, x1, x2, inter_exc, delta, b0;
Word32 L_acc, L_c, L_temp;
Word16 tmp[SubFrLen/Sgrid];
Word16 offset[SubFrames];
Word16 tempExc[SubFrLenD];
/*
* generate LTP codes
*/
Line->Olp[0] = random_number(21, nRandom) + (Word16)123;
Line->Olp[1] = random_number(21, nRandom) + (Word16)123;
for(i_subfr=0; i_subfr<SubFrames; i_subfr++) { /* in [1, NbFilt] */
Line->Sfs[i_subfr].AcGn = random_number(NbFilt, nRandom) + (Word16)1;
}
Line->Sfs[0].AcLg = 1;
Line->Sfs[1].AcLg = 0;
Line->Sfs[2].AcLg = 1;
Line->Sfs[3].AcLg = 3;
/*
* Random innovation :
* Selection of the grids, signs and pulse positions
*/
/* Signs and Grids */
ptr_TabSign = TabSign;
ptr1 = offset;
for(iblk=0; iblk<SubFrames/2; iblk++) {
temp = random_number((1 << (NbPulsBlk+2)), nRandom);
*ptr1++ = temp & (Word16)0x0001;
temp = shr(temp, 1);
*ptr1++ = add( (Word16) SubFrLen, (Word16) (temp & 0x0001) );
for(i=0; i<NbPulsBlk; i++) {
*ptr_TabSign++= shl(sub((temp & (Word16)0x0002), 1), 14);
temp = shr(temp, 1);
}
}
/* Positions */
ptr_TabPos = TabPos;
for(i_subfr=0; i_subfr<SubFrames; i_subfr++) {
for(i=0; i<(SubFrLen/Sgrid); i++) tmp[i] = (Word16)i;
temp = (SubFrLen/Sgrid);
for(i=0; i<Nb_puls[i_subfr]; i++) {
j = random_number(temp, nRandom);
*ptr_TabPos++ = add(shl(tmp[(int)j],1), offset[i_subfr]);
temp = sub(temp, 1);
tmp[(int)j] = tmp[(int)temp];
}
}
/*
* Compute fixed codebook gains
*/
ptr_TabPos = TabPos;
ptr_TabSign = TabSign;
curExc = DataExc;
i_subfr = 0;
for(iblk=0; iblk<SubFrames/2; iblk++) {
/* decode LTP only */
Decod_Acbk(curExc, &PrevExc[0], Line->Olp[iblk],
Line->Sfs[i_subfr].AcLg, Line->Sfs[i_subfr].AcGn);
Decod_Acbk(&curExc[SubFrLen], &PrevExc[SubFrLen], Line->Olp[iblk],
Line->Sfs[i_subfr+1].AcLg, Line->Sfs[i_subfr+1].AcGn);
temp2 = 0;
for(i=0; i<SubFrLenD; i++) {
temp = abs_s(curExc[i]);
if(temp > temp2) temp2 = temp;
}
if(temp2 == 0) sh1 = 0;
else {
sh1 = sub(4,norm_s(temp2)); /* 4 bits of margin */
if(sh1 < -2) sh1 = -2;
}
L_temp = 0L;
for(i=0; i<SubFrLenD; i++) {
temp = shr(curExc[i], sh1); /* left if sh1 < 0 */
L_temp = L_mac(L_temp, temp, temp);
tempExc[i] = temp;
} /* ener_ltp x 2**(-2sh1+1) */
L_acc = 0L;
for(i=0; i<NbPulsBlk; i++) {
L_acc = L_mac(L_acc, tempExc[(int)ptr_TabPos[i]], ptr_TabSign[i]);
}
inter_exc = extract_h(L_shl(L_acc, 1)); /* inter_exc x 2-sh1 */
/* compute SubFrLenD x curGain**2 x 2**(-2sh1+1) */
/* curGain input = 2**5 curGain */
// L_acc = L_mult(curGain, SubFrLen);
L_MULT(curGain, SubFrLen, L_acc);
L_acc = L_shr(L_acc, 6);
temp = extract_l(L_acc); /* SubFrLen x curGain : avoids overflows */
// L_acc = L_mult(temp, curGain);
L_MULT(temp, curGain, L_acc);
temp = shl(sh1, 1);
temp = add(temp, 4);
L_acc = L_shr(L_acc, temp); /* SubFrLenD x curGain**2 x 2**(-2sh1+1) */
/* c = (ener_ltp - SubFrLenD x curGain**2)/nb_pulses_blk */
/* compute L_c = c >> 2sh1-1 */
L_acc = L_sub(L_temp, L_acc);
/* x 1/nb_pulses_blk */
L_c = L_mls(L_acc, InvNbPulsBlk);
/*
* Solve EQ(X) = X**2 + 2 b0 X + c
*/
/* delta = b0 x b0 - c */
b0 = mult_r(inter_exc, InvNbPulsBlk); /* b0 >> sh1 */
L_acc = L_msu(L_c, b0, b0); /* (c - b0**2) >> 2sh1-1 */
L_acc = L_negate(L_acc); /* delta x 2**(-2sh1+1) */
/* Case delta <= 0 */
if(L_acc <= 0) { /* delta <= 0 */
x1 = negate(b0); /* sh1 */
}
/* Case delta > 0 */
else {
delta = Sqrt_lbc(L_acc); /* >> sh1 */
x1 = sub(delta, b0); /* x1 >> sh1 */
x2 = add(b0, delta); /* (-x2) >> sh1 */
if(abs_s(x2) < abs_s(x1)) {
x1 = negate(x2);
}
}
/* Update DataExc */
sh1 = add(sh1, 1);
temp = shl(x1, sh1);
if(temp > (2*Gexc_Max)) temp = (2*Gexc_Max);
if(temp < -(2*Gexc_Max)) temp = -(2*Gexc_Max);
for(i=0; i<NbPulsBlk; i++) {
j = *ptr_TabPos++;
curExc[(int)j] = add(curExc[(int)j], mult(temp,
(*ptr_TabSign++)) );
}
/* update PrevExc */
ptr1 = PrevExc;
for(i=SubFrLenD; i<PitchMax; i++) *ptr1++ = PrevExc[i];
for(i=0; i<SubFrLenD; i++) *ptr1++ = curExc[i];
curExc += SubFrLenD;
i_subfr += 2;
} /* end of loop on LTP blocks */
return;
}
void Levinsone(
Word16 m, /* (i) : LPC order */
Word16 Rh[], /* (i) : Rh[M+1] Vector of autocorrelations (msb) */
Word16 Rl[], /* (i) : Rl[M+1] Vector of autocorrelations (lsb) */
Word16 A[], /* (o) Q12 : A[M] LPC coefficients (m = 10) */
Word16 rc[], /* (o) Q15 : rc[M] Reflection coefficients. */
Word16 old_A[], /* (i/o) Q12 : last stable filter LPC coefficients */
Word16 old_rc[] /* (i/o) Q15 : last stable filter Reflection coefficients. */
)
{
Word16 i, j;
Word16 hi, lo;
Word16 Kh, Kl; /* reflection coefficient; hi and lo */
Word16 alp_h, alp_l, alp_exp; /* Prediction gain; hi lo and exponent */
Word16 Ah[M_BWDP1], Al[M_BWDP1]; /* LPC coef. in double prec. */
Word16 Anh[M_BWDP1], Anl[M_BWDP1]; /* LPC coef.for next iteration in double prec. */
Word32 t0, t1, t2; /* temporary variable */
Word32 tmp;
/* K = A[1] = -R[1] / R[0] */
t1 = L_Comp(Rh[1], Rl[1]); /* R[1] in Q31 */
tmp = L_Comp(Rh[0], Rl[0]);
if (t1 > tmp) t1 = tmp;
t2 = L_abs(t1); /* abs R[1] */
t0 = Div_32(t2, Rh[0], Rl[0]); /* R[1]/R[0] in Q31 */
if(t1 > 0) t0= L_negate(t0); /* -R[1]/R[0] */
L_Extract(t0, &Kh, &Kl); /* K in DPF */
rc[0] = Kh;
t0 = L_shr(t0,4); /* A[1] in Q27 */
L_Extract(t0, &Ah[1], &Al[1]); /* A[1] in DPF */
/* Alpha = R[0] * (1-K**2) */
t0 = Mpy_32(Kh ,Kl, Kh, Kl); /* K*K in Q31 */
t0 = L_abs(t0); /* Some case <0 !! */
t0 = L_sub( (Word32)0x7fffffffL, t0 ); /* 1 - K*K in Q31 */
L_Extract(t0, &hi, &lo); /* DPF format */
t0 = Mpy_32(Rh[0] ,Rl[0], hi, lo); /* Alpha in Q31 */
/* Normalize Alpha */
alp_exp = norm_l(t0);
t0 = L_shl(t0, alp_exp);
L_Extract(t0, &alp_h, &alp_l); /* DPF format */
/*--------------------------------------*
* ITERATIONS I=2 to m *
*--------------------------------------*/
for(i= 2; i<=m; i++)
{
/* t0 = SUM ( R[j]*A[i-j] ,j=1,i-1 ) + R[i] */
t0 = 0;
for(j=1; j<i; j++)
t0 = L_add(t0, Mpy_32(Rh[j], Rl[j], Ah[i-j], Al[i-j]));
t0 = L_shl(t0,4); /* result in Q27 -> convert to Q31 */
/* No overflow possible */
t1 = L_Comp(Rh[i],Rl[i]);
t0 = L_add(t0, t1); /* add R[i] in Q31 */
/* K = -t0 / Alpha */
t1 = L_abs(t0);
tmp = L_Comp(alp_h, alp_l);
if (t1 > tmp) t1 = tmp;
t2 = Div_32(t1, alp_h, alp_l); /* abs(t0)/Alpha */
if(t0 > 0) t2= L_negate(t2); /* K =-t0/Alpha */
t2 = L_shl(t2, alp_exp); /* denormalize; compare to Alpha */
L_Extract(t2, &Kh, &Kl); /* K in DPF */
rc[i-1] = Kh;
/* Test for unstable filter. If unstable keep old A(z) */
if (sub(abs_s(Kh), 32750) > 0)
{
for(j=0; j<=m; j++)
{
A[j] = old_A[j];
}
rc[0] = old_rc[0]; /* only two rc coefficients are needed */
rc[1] = old_rc[1];
return;
}
/*------------------------------------------*
* Compute new LPC coeff. -> An[i] *
* An[j]= A[j] + K*A[i-j] , j=1 to i-1 *
* An[i]= K *
*------------------------------------------*/
for(j=1; j<i; j++)
{
t0 = Mpy_32(Kh, Kl, Ah[i-j], Al[i-j]);
t0 = L_add(t0, L_Comp(Ah[j], Al[j]));
L_Extract(t0, &Anh[j], &Anl[j]);
}
t2 = L_shr(t2, 4); /* t2 = K in Q31 ->convert to Q27 */
L_Extract(t2, &Anh[i], &Anl[i]); /* An[i] in Q27 */
/* Alpha = Alpha * (1-K**2) */
t0 = Mpy_32(Kh ,Kl, Kh, Kl); /* K*K in Q31 */
t0 = L_abs(t0); /* Some case <0 !! */
t0 = L_sub( (Word32)0x7fffffffL, t0 ); /* 1 - K*K in Q31 */
L_Extract(t0, &hi, &lo); /* DPF format */
t0 = Mpy_32(alp_h , alp_l, hi, lo); /* Alpha in Q31 */
/* Normalize Alpha */
j = norm_l(t0);
t0 = L_shl(t0, j);
L_Extract(t0, &alp_h, &alp_l); /* DPF format */
alp_exp = add(alp_exp, j); /* Add normalization to alp_exp */
/* A[j] = An[j] */
for(j=1; j<=i; j++)
{
Ah[j] =Anh[j];
Al[j] =Anl[j];
}
}
/* Truncate A[i] in Q27 to Q12 with rounding */
A[0] = 4096;
for(i=1; i<=m; i++)
{
t0 = L_Comp(Ah[i], Al[i]);
old_A[i] = A[i] = round(L_shl(t0, 1));
}
old_rc[0] = rc[0];
old_rc[1] = rc[1];
return;
}
/*
**
** Function: AtoLsp()
**
** Description: Transforms 10 LPC coefficients to the 10
** corresponding LSP frequencies for a subframe.
** This transformation is done once per frame,
** for subframe 3 only. The transform algorithm
** generates sum and difference polynomials from
** the LPC coefficients. It then evaluates the
** sum and difference polynomials at uniform
** intervals of pi/256 along the unit circle.
** Intervals where a sign change occurs are
** interpolated to find the zeros of the
** polynomials, which are the LSP frequencies.
**
** Links to text: Section 2.5
**
** Arguments:
**
** Word16 *LspVect Empty Buffer
** Word16 Lpc[] Unquantized LPC coefficients (10 words)
** Word16 PrevLsp[] LSP frequencies from the previous frame (10 words)
**
** Outputs:
**
** Word16 LspVect[] LSP frequencies for the current frame (10 words)
**
** Return value: None
**
**/
void AtoLsp( Word16 *LspVect, Word16 *Lpc, Word16 *PrevLsp )
{
int i,j,k ;
Word32 Lpq[LpcOrder+2] ;
Word16 Spq[LpcOrder+2] ;
Word16 Exp ;
Word16 LspCnt ;
Word32 PrevVal,CurrVal ;
Word32 Acc0,Acc1 ;
/*
* Perform a bandwidth expansion on the LPC coefficients. This
* scales the poles of the LPC synthesis filter by a factor of
* 0.994.
*/
for ( i = 0 ; i < LpcOrder ; i ++ )
LspVect[i] = mult_r( Lpc[i], BandExpTable[i] ) ;
/*
* Compute the sum and difference polynomials with the roots at z =
* -1 (sum) or z = +1 (difference) removed. Let these polynomials
* be P(z) and Q(z) respectively, and let their coefficients be
* {p_i} amd {q_i}. The coefficients are stored in the array Lpq[]
* as follows: p_0, q_0, p_1, q_1, ..., p_5, q_5. There is no need
* to store the other coefficients because of symmetry.
*/
/*
* Set p_0 = q_0 = 1. The LPC coefficients are already scaled by
* 1/4. P(z) and Q(z) are scaled by an additional scaling factor of
* 1/16, for an overall factor of 1/64 = 0x02000000L.
*/
Lpq[0] = Lpq[1] = (Word32) 0x02000000L ;
/*
* This loop computes the coefficients of P(z) and Q(z). The long
* division (to remove the real zeros) is done recursively.
*/
for ( i = 0 ; i < LpcOrder/2 ; i ++ ) {
/* P(z) */
Acc0 = L_negate( Lpq[2*i+0] ) ;
Acc1 = L_deposit_h( LspVect[i] ) ;
Acc1 = L_shr( Acc1, (Word16) 4 ) ;
Acc0 = L_sub( Acc0, Acc1 ) ;
Acc1 = L_deposit_h( LspVect[LpcOrder-1-i] ) ;
Acc1 = L_shr( Acc1, (Word16) 4 ) ;
Acc0 = L_sub( Acc0, Acc1 ) ;
Lpq[2*i+2] = Acc0 ;
/* Q(z) */
Acc0 = Lpq[2*i+1] ;
Acc1 = L_deposit_h( LspVect[i] ) ;
Acc1 = L_shr( Acc1, (Word16) 4 ) ;
Acc0 = L_sub( Acc0, Acc1 ) ;
Acc1 = L_deposit_h( LspVect[LpcOrder-1-i] ) ;
Acc1 = L_shr( Acc1, (Word16) 4 ) ;
// Acc0 = L_add( Acc0, Acc1 ) ;
L_ADD(Acc0, Acc1, Acc0);
Lpq[2*i+3] = Acc0 ;
}
/*
* Divide p_5 and q_5 by 2 for proper weighting during polynomial
* evaluation.
*/
Lpq[LpcOrder+0] = L_shr( Lpq[LpcOrder+0], (Word16) 1 ) ;
Lpq[LpcOrder+1] = L_shr( Lpq[LpcOrder+1], (Word16) 1 ) ;
/*
* Normalize the polynomial coefficients and convert to shorts
*/
/* Find the maximum */
Acc1 = L_abs( Lpq[0] ) ;
for ( i = 1 ; i < LpcOrder+2 ; i ++ ) {
Acc0 = L_abs( Lpq[i] ) ;
if ( Acc0 > Acc1 )
Acc1 = Acc0 ;
}
/* Compute the normalization factor */
Exp = norm_l( Acc1 ) ;
/* Normalize and convert to shorts */
for ( i = 0 ; i < LpcOrder+2 ; i ++ ) {
Acc0 = L_shl( Lpq[i], Exp ) ;
Spq[i] = round( Acc0 ) ;
}
/*
* Initialize the search loop
*/
/*
* The variable k is a flag that indicates which polynomial (sum or
* difference) the algorithm is currently evaluating. Start with
* the sum.
*/
k = 0 ;
/* Evaluate the sum polynomial at frequency zero */
PrevVal = (Word32) 0 ;
for ( j = 0 ; j <= LpcOrder/2 ; j ++ )
PrevVal = L_mac( PrevVal, Spq[2*j], CosineTable[0] ) ;
/*
* Search loop. Evaluate P(z) and Q(z) at uniform intervals of
* pi/256 along the unit circle. Check for zero crossings. The
* zeros of P(w) and Q(w) alternate, so only one of them need by
* evaluated at any given step.
*/
LspCnt = (Word16) 0 ;
for ( i = 1 ; i < CosineTableSize/2 ; i ++ ) {
/* Evaluate the selected polynomial */
CurrVal = (Word32) 0 ;
for ( j = 0 ; j <= LpcOrder/2 ; j ++ )
CurrVal = L_mac( CurrVal, Spq[LpcOrder-2*j+k],
CosineTable[i*j%CosineTableSize] ) ;
/* Check for a sign change, indicating a zero crossing */
if ( (CurrVal ^ PrevVal) < (Word32) 0 ) {
/*
* Interpolate to find the bottom 7 bits of the
* zero-crossing frequency
*/
Acc0 = L_abs( CurrVal ) ;
Acc1 = L_abs( PrevVal ) ;
// Acc0 = L_add( Acc0, Acc1 ) ;
L_ADD(Acc0, Acc1, Acc0);
/* Normalize the sum */
Exp = norm_l( Acc0 ) ;
Acc0 = L_shl( Acc0, Exp ) ;
Acc1 = L_shl( Acc1, Exp ) ;
Acc1 = L_shr( Acc1, (Word16) 8 ) ;
LspVect[LspCnt] = div_l( Acc1, extract_h( Acc0 ) ) ;
/*
* Add the upper part of the zero-crossing frequency,
* i.e. bits 7-15
*/
Exp = shl( (Word16) (i-1), (Word16) 7 ) ;
LspVect[LspCnt] = add( LspVect[LspCnt], Exp ) ;
LspCnt ++ ;
/* Check if all zeros have been found */
if ( LspCnt == (Word16) LpcOrder )
break ;
/*
* Switch the pointer between sum and difference polynomials
*/
k ^= 1 ;
/*
* Evaluate the new polynomial at the current frequency
*/
CurrVal = (Word32) 0 ;
for ( j = 0 ; j <= LpcOrder/2 ; j ++ )
CurrVal = L_mac( CurrVal, Spq[LpcOrder-2*j+k],
CosineTable[i*j%CosineTableSize] ) ;
}
/* Update the previous value */
PrevVal = CurrVal ;
}
/*
* Check if all 10 zeros were found. If not, ignore the results of
* the search and use the previous frame's LSP frequencies instead.
*/
if ( LspCnt != (Word16) LpcOrder ) {
for ( j = 0 ; j < LpcOrder ; j ++ )
LspVect[j] = PrevLsp[j] ;
}
return ;
}
void GetExc800bps(
/* 1 */ short *output,
/* 2 */ short *best,
/* 3 */ short scale,
/* 4 */ short *input,
/* 5 */ short length,
/* 6 */ short flag,
/* 7 */ short n)
{
short k, j;
short D;
long tmp;
long ltmp;
short stmp;
short *ptr;
long sum, lscale;
short ssum, sscale;
static short Seed = 1234;
static short Sum[NoOfSubFrames];
short shft_scale;
short shft_sum;
short stemp1;
if (!flag)
Seed = 1234;
/*
* sum is an integer value, not a fractional value.
*/
/* Get energy of next sub frame */
for (k = 0, sum = 0; k < length; k++)
{
sum = L_add(sum, L_deposit_l(abs_s(input[k])));
}
sum = L_shl(sum, 1); /* correct for scaling */
if (sum < SubFrameSize)
{
sum = fnLog10(L_deposit_h(scale));
sum = L_negate(L_add(L_shl(sum, 3), 484942745)); /* add (log8)/4 = 484842745 (VALUE ADJUSTED TO BETTER MATCH FLOAT MODEL) */
}
else
{
lscale = L_mult(SubFrameSize, scale);
shft_scale = norm_l(lscale);
sscale = round(L_shl(lscale, shft_scale));
shft_sum = norm_l(sum) - 1;
ssum = round(L_shl(sum, shft_sum));
/*
* The following divide/L_shl produced sum scaled down by 64.
* sum can have a max value of 40.xx in the sample data.
*/
/* sum = L_shl(L_divide(sum, lscale), (shft_scale + 7 - shft_sum)); */
sum = L_deposit_h(shl(divide_s(ssum, sscale), (shft_scale - shft_sum)));
/* sum = fnLog10(sum); */
sum = L_add(fnLog10(sum), 141412467); /* add log (2^7) scaled down by 32 */
sum = L_add(L_shl(sum, 3), 969485490); /* add (log8)/2 = 969685490 (VALUE ADJUSTED TO BETTER MATCH FLOAT MODEL) */
}
/*
* Sum scaled down by 4.
*/
Sum[n] = round(sum);
/* Quantize if last frame */
if (n == NoOfSubFrames - 1)
{
/* Quantize to 8 bits */
for (k = 0, sum = 2147483647, ptr = Logqtbl; k < 256; k++)
{
for (j = 0, tmp = 0; j < 3; j++)
{
/*
* Sum and Logqtbl both scaled down by 4.
* Change Logqtbl to short if Lw not required.
*/
D = sub(Sum[j], (*ptr++));
tmp = L_mac(tmp, D, D);
}
if (tmp < sum)
{
ltmp = sum;
sum = tmp;
*best = k;
}
}
for (j = 0; j < 3; j++)
{
Sum[j] = Powqtbl[*best * 3 + j];
}
/* Get excitation */
j = FrameSize - ACBMemSize;
for (k = 0; k < FrameSize - 1; k++)
{
if (k >= j)
{
stmp = e_ran_g(&Seed);
stemp1 = k / (length - 1);
output[k - j] = round(L_shr(L_mult(stmp, Sum[stemp1]), 5));
}
}
stmp = e_ran_g(&Seed);
output[k - j] = round(L_shr(L_mult(stmp, Sum[2]), 5)); /* last excitation */
}
}
short e_ran_g(short *seed0)
{
static int iset = 0;
static long gset;
long rsq, ltemp1, ltemp2;
short sv1, sv2, rsq_s;
short shft_fctr, stemp1;
short shft_fctr1;
/* ======================================================================== */
long ltmp1, ltmp2;
short ans = 0;
short stmp2;
/* ======================================================================== */
if (iset == 0)
{
sv1 = shl(sub(ran0(seed0), 16384), 1);
sv2 = shl(sub(ran0(seed0), 16384), 1);
/* rsq = sv1 * sv1 + sv2 * sv2; */
ltemp1 = L_mult(sv1, sv1);
ltemp2 = L_mult(sv2, sv2);
rsq = L_add(L_shr(ltemp1, 1), L_shr(ltemp2, 1));
if (rsq >= 1073741824 || rsq == 0){
/* If condition not met, don't iterate; use */
/* rough approximation. */
ans = shr(sv1,3);
ans = add(ans, shr(sv2,3));
ans = add(ans, shr(sub(ran0(seed0), 16384),2));
return (ans);
}
/*
* error in rsq doesn't seem to contribute to the final error in e_ran_g
*/
/*
* rsq scale down by two: input to fnLog must be scaled up by 2.
*/
rsq = L_shl(rsq, 1);
/* stemp1 = round(L_negate(fnLog(rsq))); */
ltmp1 = L_negate(fnLog(rsq));
/*
* rsq must be greater than the log of lsq for the fractional
* divide to work. therfore normalize rsq.
*/
shft_fctr = norm_l(rsq);
rsq_s = round(L_shl(rsq, shft_fctr));
stmp2 = (divide_s(round(ltmp1), rsq_s));
/*
* stemp2 must be normalized before taking its square root.
* (increases precision).
*/
shft_fctr1 = norm_s(stmp2);
ltmp2 = L_deposit_h(shl(stmp2, shft_fctr1));
stemp1 = sqroot(ltmp2);
/*
* shifting involved before taking the square root:
* LEFT << shft_fctr. (LEFT because rsq is in the denominator
* of ltemp2 quotion).
* LEFT << 6. (multiply by 2 in original code and multiply by 32
* because output of fnLog scaled down by 32).
* RIGHT >> shft_fctr1. (normalization taken before sqroot).
*/
shft_fctr = shft_fctr + 6 - shft_fctr1;
/*
* PROPERTY: sqrt(2^n) = 2^(n/2)
* if shft_fctr is odd; multiply stemp1 by sqrt(2)/2 and
* increment number of shifts by 1. Can now use shft_fctr / 2.
*/
if (shft_fctr & 0x0001)
{
stemp1 = mult(stemp1, 23170);
shft_fctr++;
}
shft_fctr = shr(shft_fctr, 1);
/*
* normalize stemp1 for the following multiplication.
* adjust shft_fctr accordingly.
*/
shft_fctr1 = norm_s(stemp1);
stemp1 = shl(stemp1, shft_fctr1);
shft_fctr = shft_fctr - shft_fctr1;
gset = L_mult(sv1, stemp1);
/*
* final output is scaled down by 4, therefore shift up by
* shft_fctr - 2.
*/
gset = L_shl(gset, shft_fctr - 2);
iset = 1;
return round(L_shl(L_mult(sv2, stemp1), shft_fctr - 2));
}
else
{
iset = 0;
return round(gset);
}
}
Word16 spectral_comparison (
Word16 rav1[],
Word16 scal_rav1,
Word32 L_av0[]
)
{
Word32 L_dm, L_sump, L_temp;
Word16 stat, sav0[9], shift, divshift, temp;
Word16 i;
/*** Re-normalize L_av0[0..8] ***/
if (L_av0[0] == 0L)
{
for (i = 0; i <= 8; i++)
{
sav0[i] = 0x0fff; /* 4095 */
}
}
else
{
shift = sub (norm_l (L_av0[0]), 3);
for (i = 0; i <= 8; i++)
{
if(shift<=0)
sav0[i] = extract_h (L_shr (L_av0[i], -shift));
else
sav0[i] = extract_h (L_shl (L_av0[i], shift));
}
}
/*** Compute partial sum of dm ***/
L_sump = 0L;
for (i = 1; i <= 8; i++)
{
L_sump = L_mac (L_sump, rav1[i], sav0[i]);
}
/*** Compute the division of the partial sum by sav0[0] ***/
if (L_sump < 0L)
{
L_temp = L_negate (L_sump);
}
else
{
L_temp = L_sump;
}
if (L_temp == 0L)
{
L_dm = 0L;
shift = 0;
}
else
{
sav0[0] = shl (sav0[0], 3);
shift = norm_l (L_temp);
if(shift<=0)
temp = extract_h (L_shr (L_temp, -shift));
else
temp = extract_h (L_shl (L_temp, shift));
if (sub (sav0[0], temp) >= 0)
{
divshift = 0;
temp = div_s (temp, sav0[0]);
}
else
{
divshift = 1;
temp = sub (temp, sav0[0]);
temp = div_s (temp, sav0[0]);
}
if (sub (divshift, 1) == 0)
{
L_dm = 0x8000L;
}
else
{
L_dm = 0L;
}
L_dm = L_shl (L_add (L_dm, L_deposit_l (temp)), 1);
if (L_sump < 0L)
{
L_dm = L_negate (L_dm);
}
}
/*** Re-normalization and final computation of L_dm ***/
L_dm = L_shl (L_dm, 14);
if(shift<0)
L_dm = L_shl (L_dm, -shift);
else
L_dm = L_shr (L_dm, shift);
L_dm = L_add (L_dm, L_shl (L_deposit_l (rav1[0]), 11));
if(scal_rav1<0)
L_dm = L_shl (L_dm, -scal_rav1);
else
L_dm = L_shr (L_dm, scal_rav1);
/*** Compute the difference and save L_dm ***/
L_temp = L_sub (L_dm, L_lastdm);
L_lastdm = L_dm;
if (L_temp < 0L)
{
L_temp = L_negate (L_temp);
}
/*** Evaluation of the stat flag ***/
L_temp = L_sub (L_temp, STAT_THRESH);
if (L_temp < 0L)
{
stat = 1;
}
else
{
stat = 0;
}
return stat;
}
/*************************************************************************
*
* FUNCTION: Levinson()
*
* PURPOSE: Levinson-Durbin algorithm in double precision. To compute the
* LP filter parameters from the speech autocorrelations.
*
* DESCRIPTION:
* R[i] autocorrelations.
* A[i] filter coefficients.
* K reflection coefficients.
* Alpha prediction gain.
*
* Initialisation:
* A[0] = 1
* K = -R[1]/R[0]
* A[1] = K
* Alpha = R[0] * (1-K**2]
*
* Do for i = 2 to M
*
* S = SUM ( R[j]*A[i-j] ,j=1,i-1 ) + R[i]
*
* K = -S / Alpha
*
* An[j] = A[j] + K*A[i-j] for j=1 to i-1
* where An[i] = new A[i]
* An[i]=K
*
* Alpha=Alpha * (1-K**2)
*
* END
*
*************************************************************************/
int Levinson (
LevinsonState *st,
Word16 Rh[], /* i : Rh[m+1] Vector of autocorrelations (msb) */
Word16 Rl[], /* i : Rl[m+1] Vector of autocorrelations (lsb) */
Word16 A[], /* o : A[m] LPC coefficients (m = 10) */
Word16 rc[] /* o : rc[4] First 4 reflection coefficients */
)
{
Word16 i, j;
Word16 hi, lo;
Word16 Kh, Kl; /* reflexion coefficient; hi and lo */
Word16 alp_h, alp_l, alp_exp; /* Prediction gain; hi lo and exponent */
Word16 Ah[M + 1], Al[M + 1]; /* LPC coef. in double prec. */
Word16 Anh[M + 1], Anl[M + 1];/* LPC coef.for next iteration in double
prec. */
Word32 t0, t1, t2; /* temporary variable */
/* K = A[1] = -R[1] / R[0] */
t1 = L_Comp (Rh[1], Rl[1]);
t2 = L_abs (t1); /* abs R[1] */
t0 = Div_32 (t2, Rh[0], Rl[0]); /* R[1]/R[0] */
if (t1 > 0)
t0 = L_negate (t0); /* -R[1]/R[0] */
L_Extract (t0, &Kh, &Kl); /* K in DPF */
rc[0] = round (t0);
t0 = L_shr (t0, 4); /* A[1] in */
L_Extract (t0, &Ah[1], &Al[1]); /* A[1] in DPF */
/* Alpha = R[0] * (1-K**2) */
t0 = Mpy_32 (Kh, Kl, Kh, Kl); /* K*K */
t0 = L_abs (t0); /* Some case <0 !! */
t0 = L_sub ((Word32) 0x7fffffffL, t0); /* 1 - K*K */
L_Extract (t0, &hi, &lo); /* DPF format */
t0 = Mpy_32 (Rh[0], Rl[0], hi, lo); /* Alpha in */
/* Normalize Alpha */
alp_exp = norm_l (t0);
t0 = L_shl (t0, alp_exp);
L_Extract (t0, &alp_h, &alp_l); /* DPF format */
/*--------------------------------------*
* ITERATIONS I=2 to M *
*--------------------------------------*/
for (i = 2; i <= M; i++)
{
/* t0 = SUM ( R[j]*A[i-j] ,j=1,i-1 ) + R[i] */
t0 = 0;
for (j = 1; j < i; j++)
{
t0 = L_add (t0, Mpy_32 (Rh[j], Rl[j], Ah[i - j], Al[i - j]));
}
t0 = L_shl (t0, 4);
t1 = L_Comp (Rh[i], Rl[i]);
t0 = L_add (t0, t1); /* add R[i] */
/* K = -t0 / Alpha */
t1 = L_abs (t0);
t2 = Div_32 (t1, alp_h, alp_l); /* abs(t0)/Alpha */
if (t0 > 0)
t2 = L_negate (t2); /* K =-t0/Alpha */
t2 = L_shl (t2, alp_exp); /* denormalize; compare to Alpha */
L_Extract (t2, &Kh, &Kl); /* K in DPF */
if (sub (i, 5) < 0)
{
rc[i - 1] = round (t2);
}
/* Test for unstable filter. If unstable keep old A(z) */
if (sub (abs_s (Kh), 32750) > 0)
{
for (j = 0; j <= M; j++)
{
A[j] = st->old_A[j];
}
for (j = 0; j < 4; j++)
{
rc[j] = 0;
}
return 0;
}
/*------------------------------------------*
* Compute new LPC coeff. -> An[i] *
* An[j]= A[j] + K*A[i-j] , j=1 to i-1 *
* An[i]= K *
*------------------------------------------*/
for (j = 1; j < i; j++)
{
t0 = Mpy_32 (Kh, Kl, Ah[i - j], Al[i - j]);
t0 = L_add(t0, L_Comp(Ah[j], Al[j]));
L_Extract (t0, &Anh[j], &Anl[j]);
}
t2 = L_shr (t2, 4);
L_Extract (t2, &Anh[i], &Anl[i]);
/* Alpha = Alpha * (1-K**2) */
t0 = Mpy_32 (Kh, Kl, Kh, Kl); /* K*K */
t0 = L_abs (t0); /* Some case <0 !! */
t0 = L_sub ((Word32) 0x7fffffffL, t0); /* 1 - K*K */
L_Extract (t0, &hi, &lo); /* DPF format */
t0 = Mpy_32 (alp_h, alp_l, hi, lo);
/* Normalize Alpha */
j = norm_l (t0);
t0 = L_shl (t0, j);
L_Extract (t0, &alp_h, &alp_l); /* DPF format */
alp_exp = add (alp_exp, j); /* Add normalization to
alp_exp */
/* A[j] = An[j] */
for (j = 1; j <= i; j++)
{
Ah[j] = Anh[j];
Al[j] = Anl[j];
}
}
A[0] = 4096;
for (i = 1; i <= M; i++)
{
t0 = L_Comp (Ah[i], Al[i]);
st->old_A[i] = A[i] = round (L_shl (t0, 1));
}
return 0;
}
