// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "types.h"

 #include "rpeltp.h"

 #include "basicop.h"

 #include "tables.h"

 #include "gsm610fr.h"

 /*

 ** Static variables are allocated as globals in order to make it

 ** possible to clear them in run time (reset codec). This might be

 ** useful e.g. in possible EC code

 */

 /*

 ** void reset_encoder(CGSM610FR_Encoder* aEncoder)

 **

 ** Function clears encoder variables.

 ** Input:

 **   None

 ** Output:

 **   Clear z1, L_z2, mp, LARpp_Prev[0..7], u[0..7], dp[0..119]

 ** Return value:

 **   None

 */

 void reset_encoder(CGSM610FR_Encoder* aEncoder)

 {

   int i;

   aEncoder->z1 = 0;

   aEncoder->L_z2 = 0;

   aEncoder->mp = 0;

   for ( i = 0; i <= 7; i++ )

     aEncoder->LARpp_prev[i] = 0;

   for ( i = 0; i <= 7; i++ )

     aEncoder->u[i] = 0;

   for ( i = 0; i <= 119; i++ )

     aEncoder->dp[i] = 0;

 }

 /*

 ** void reset_decoder(CGSM610FR_Encoder* aDecoder)

 **

 ** Function clears decoder variables.

 ** Input:

 **   None

 ** Output:

 **   Clear LARpp_Prev[0..7], v[0..8], drp[0..119], nrp

 ** Return value:

 **   None

 */

 void reset_decoder(CGSM610FR_Decoder* aDecoder)

 {

   int i;

   for ( i = 0; i <= 7; i++ )

     aDecoder->LARrpp_prev[i] = 0;

   for ( i = 0; i <= 8; i++ )

     aDecoder->v[i] = 0;

   aDecoder->msr = 0;

   for ( i = 0; i <= 119; i++ )

     aDecoder->drp[i] = 0;

   aDecoder->nrp = 40;

 }

 /*

 #  4.2.1. Downscaling of the input signal

 #

 #  4.2.2. Offset compensation

 #

 #  This part implements a high-pass filter and requires extended

 #  arithmetic precision for the recursive part of this filter.

 #

 #  The input of this procedure is the array so[0..159] and the output

 #  array sof[0..159].

 #

 #  Keep z1 and L_z2 in memory for the next frame.

 #  Initial value: z1=0; L_z2=0;

 @  Downscaling and offset compensation are combined in order to spare

 @  unnecessary data moves.

 */

 void prepr( CGSM610FR_Encoder* aEncoder, int2 sof[], int2 so[] )

 {

   int k;

   int2 msp;

   int2 temp;

   int4 L_s2;

 /*

 # 4.2.1. Downscaling of the input signal

 # |== FOR k=0 to 159:

 # | so[k] = sop[k] >> 3;

 # | so[k] = so[k] << 2;

 # |== NEXT k:

 */

 /*

 # |== FOR k = 0 to 159:

 # |Compute the non-recursive part.

 # | s1 = sub( so[k], z1 );

 # | z1 = so[k];

 # |Compute the recursive part.

 # | L_s2 = s1;

 # | L_s2 = L_s2 << 15;

 # |Execution of a 31 by 16 bits multiplication.

 # | msp = L_z2 >> 15;

 # | lsp = L_sub( L_z2, ( msp << 15 ) );

 # | temp = mult_r( lsp, 32735 );

 # | L_s2 = L_add( L_s2, temp );

 # | L_z2 = L_add( L_mult( msp, 32735 ) >> 1, L_s2 );

 # |Compute sof[k] with rounding.

 # | sof[k] = L_add( L_z2, 16384 ) >> 15;

 # |== NEXT k:

 */

   for (k=0; k <= 159; k++) {

     /* Downscaling */

     temp = shl( shr( so[k], 3 ), 2 );

     /* Compute the non-recursive part. */

     /* Compute the recursive part. */

     L_s2 = L_deposit_l( sub( temp, aEncoder->z1 ) );

     aEncoder->z1 = temp;

     L_s2 = L_shl( L_s2, 15 );

     /* Execution of a 31 by 16 bits multiplication. */

     msp = extract_l( L_shr( aEncoder->L_z2, 15 ) );

     temp = extract_l( L_sub( aEncoder->L_z2, L_shl( L_deposit_l( msp ), 15 ) ) );

     temp = mult_r( temp, 32735 );

     L_s2 = L_add( L_s2, L_deposit_l( temp ) );

     aEncoder->L_z2 = L_add( L_shr( L_mult( msp, 32735 ), 1 ), L_s2 );

     /* Compute sof[k] with rounding. */

     sof[k] = extract_l( L_shr( L_add( aEncoder->L_z2, (int4) 16384 ), 15 ) );

   }

 }

 /*

 #  4.2.3. Preemphasis

 #

 #  Keep mp in memory for the next frame.

 #  Initial value: mp=0;

 */

 void preemp( CGSM610FR_Encoder* aEncoder, int2 s[], int2 sof[] )

 {

   int k;

   int2 temp;

 /*

 # |== FOR k=0 to 159:

 # | s[k] = add( sof[k], mult_r( mp, -28180 ) );

 # | mp = sof[k];

 # |== NEXT k:

 */

 /*

 @ Reverse looping in order to make it possible to

 @ update filter delay mp only at the end of the loop

 */

   temp = sof[159]; /* make overwrite possible */

   for ( k = 159; k >= 1; k-- )

     s[k] = add( sof[k], mult_r( sof[k-1], -28180 ) );

   s[0] = add( sof[0], mult_r( aEncoder->mp, -28180 ) );

   aEncoder->mp = temp;

 }

 /*

 #  4.2.4. Autocorrelation

 #

 #  The goal is to compute the array L_ACF[k]. The signal s[i] must be

 #  scaled in order to avoid an overflow situation.

 *

 * output:

 *       scalauto (return value)

 *

 */

 int2 autoc( int4 L_ACF[], int2 s[] )

 {

   int k, i;

   int2 smax;

   int2 temp;

   int4 L_temp2;

   int2 scalauto;

 /*

 # Dynamic scaling of the array s[0..159].

 #

 # Search for the maximum.

 #

 # smax=0;

 # |== FOR k = 0 to 159:

 # | temp = abs( s[k] );

 # | IF ( temp > smax ) THEN smax = temp;

 # |== NEXT k;

 */

   smax = 0;

   for ( k = 0; k <= 159; k++ ) {

     temp = abs_s( s[k] );

     if ( sub( temp, smax ) > 0 )

       smax = temp;

   }

 /*

 # Computation of the scaling factor.

 #

 # IF ( smax == 0 ) THEN scalauto = 0;

 #    ELSE scalauto = sub( 4, norm( smax << 16 ) );

 */

   if ( smax == 0 )

     scalauto = 0;

   else

     scalauto = sub( 4, norm_l( L_deposit_h( smax ) ) );

 /* 

 # Scaling of the array s[0..159].

 # IF ( scalauto > 0 ) THEN

 #    | temp = 16384 >> sub( scalauto, 1 );

 #    |== FOR k=0 to 159:

 #    |    s[k] = mult_r( s[k], temp );

 #    |== NEXT k:

 */

   if ( scalauto > 0 ) {

     temp = shr( 16384, sub( scalauto, 1 ) );

     for ( k = 0; k <= 159; k++ ) 

       s[k] = mult_r( s[k], temp );

   }

 /*

 # Compute the L_ACF[..].

 # |== FOR k=0 to 8:

 # |     L_ACF[k] = 0;

 # |==== FOR i=k to 159:

 # |         L_temp = L_mult( s[i], s[i-k] );

 # |         L_ACF[k] = L_add( L_ACF[k], L_temp );

 # |==== NEXT i:

 # |== NEXT k:

 */

   for ( k = 0; k <= 8; k++ ) {

     L_temp2 = 0;

     for ( i = k; i <= 159; i++ )

 	L_temp2 = L_mac( L_temp2, s[i], s[i-k] );

     L_ACF[k] = L_temp2;

   }

 /*

 # Rescaling of the array s[0..159].

 #

 # IF ( scalauto > 0 ) THEN

 #   |== FOR k = 0 to 159:

 #   |    s[k] = s[k] << scalauto;

 #   |== NEXT k:

 */

   if ( scalauto > 0 ) {

     for ( k = 0; k <= 159; k++ )

 	 s[k] = shl( s[k], scalauto );

   }

   return(scalauto); /* scalauto is retuned to be used also in vad */

 }

 /*

 #  4.2.5. Computation of the reflection coefficients

 */

 void schur( int2 r[], int4 L_ACF[] )

 {

   int k, i, n, m;

   int2 P[9];

   int2 K[7];

   int2 ACF[9];

   int2 normacf;

 /*

 # Schur recursion with 16 bits arithmetic

 #

 #    IF ( L_ACF[0] == 0 ) THEN

 #                   |== FOR i=1 to 8:

 #                   |    r[i] = 0;

 #                   |== NEXT i:

 #                   |    EXIT; / continue with section 4.2.6/

 #    normacf = norm( L_ACF[0] ); / temp is spec replaced with normacf /

 #    |== FOR k=0 to 8:

 #    |    ACF[k] = ( L_ACF[k] << normacf ) >> 16;

 #    |== NEXT k:

 */

   if ( L_ACF[0] == 0 ) {

     for ( i = 0; i <= 7; i++)

 	 r[i] = 0;

     return; /* continue with section 4.2.6 */

   }

   normacf = norm_l( L_ACF[0] );

   for ( k = 0; k <= 8; k++ )

     ACF[k] = extract_h( L_shl( L_ACF[k], normacf ) );

 /*

 # Initialize array P[..] and K[..] for the recursion.

 #

 #    |== FOR i=1 to 7:

 #    |    K[9-i] = ACF[i];

 #    |== NEXT i:

 #

 #    |== FOR i=0 to 8:

 #    |    P[i] = ACF[i];

 #    |== NEXT i:

 */

   for ( i = 1; i <= 7; i++ )

     K[7-i] = ACF[i];

   for ( i = 0; i <= 8; i++ )

     P[i] = ACF[i];

 /*

 # Compute reflection coefficients

 #    |== FOR n=1 to 8:

 #    |    IF ( P[0] < abs( P[1] ) ) THEN

 #    |                        |== FOR i=n to 8:

 #    |                        |    r[i] = 0;

 #    |                        |== NEXT i:

 #    |                        |    EXIT; /continue with

 #    |                        |    section 4.2.6./

 #    |    r[n] = div( abs( P[1] ), P[0] );

 #    |    IF ( P[1] > 0 ) THEN r[n] = sub( 0, r[n] );

 #    |

 #    |    IF ( n == 8 ) THEN EXIT; /continue with section 4.2.6/

 #    |    Schur recursion

 #    |    P[0] = add( P[0], mult_r( P[1], r[n] ) );

 #    |==== FOR m=1 to 8-n:

 #    |         P[m] = add( P[m+1], mult_r( K[9-m], r[n] ) );

 #    |         K[9-m] = add( K[9-m], mult_r( P[m+1], r[n] ) );

 #    |==== NEXT m:

 #    |

 #    |== NEXT n:

 */

   for ( n = 0; n <= 7; n++ )  {

     if ( sub( P[0], abs_s( P[1] ) ) < 0 ) {

 	 for ( i = n; i <= 7; i++ )

 	   r[i] = 0;

 	 return; /* continue with section 4.2.6. */

     }

     if ( P[1] > 0 )

 	 r[n] = negate( div_s( P[1], P[0] ) );

     else

 	 r[n] = div_s( negate( P[1] ), P[0] );

     if ( sub(int2 (n), 7) == 0 )

 	 return; /* continue with section 4.2.6 */

     /* Schur recursion */

     P[0] = add( P[0], mult_r( P[1], r[n] ) );

     for ( m = 1; m <= 7-n; m++ ) {

 /*

  *    mac_r cannot be used because it rounds the result after

  *    addition when add( xx, mult_r ) rounds first the result

  *    of the product. That is why the following two lines cannot

  *    be used instead of the curently used lines.

  *

  *    P[m] = mac_r( L_deposit_l( P[m+1] ), K[7-m], r[n] );

  *    K[7-m] = mac_r( L_deposit_l( K[7-m] ), P[m+1], r[n] );

 */

       P[m] = add( P[m+1], mult_r( K[7-m], r[n] ) );

       K[7-m] = add( K[7-m], mult_r( P[m+1], r[n] ) );

     }

   }

 }

 /*

 #  4.2.6. Transformation of reflection coefficients to Log.-Area Ratios -----

 #

 #  The following scaling for r[..] and LAR[..] has been used:

 #

 #  r[..] = integer( real_r[..]*32768. ); -1. <= real_r < 1.

 #  LAR[..] = integer( real_LAR[..]*16384. );

 #  with -1.625 <= real_LAR <= 1.625

 */

 void larcomp( int2 LAR[], int2 r[] )

 {

   int i;

   int2 temp;

 /*

 # Computation of the LAR[1..8] from the r[1..8]

 #    |== FOR i=1 to 8:

 #    |    temp = abs( r[i] );

 #    |    IF ( temp < 22118 ) THEN temp = temp >> 1;

 #    |         else if ( temp < 31130 ) THEN temp = sub( temp, 11059 );

 #    |              else temp = sub( temp, 26112 ) << 2;

 #    |    LAR[i] = temp;

 #    |    IF ( r[i] < 0 ) THEN LAR[i] = sub( 0, LAR[i] );

 #    |== NEXT i:

 */

   for ( i = 1; i <= 8; i++ ) {

 	int j = i-1;

     temp = abs_s( r[j] );

     if ( sub( temp, 22118 ) < 0 )

       temp = shr( temp, 1 );

     else if ( sub( temp, 31130 ) < 0 )

       temp = sub( temp, 11059 );

     else

       temp = shl( sub( temp, 26112 ), 2 );

     if ( r[j] < 0 )

       LAR[j] = negate( temp );

     else

       LAR[j] = temp;

   }

 }

 /*

 #  4.2.7. Quantization and coding of the Log.-Area Ratios

 #

 #  This procedure needs fpur tables; following equations give the

 #  optimum scaling for the constants:

 #

 #  A[1..8]=integer( real_A[1..8]*1024 ); 8 values (see table 4.1)

 #  B[1..8]=integer( real_B[1..8]*512 );  8 values (see table 4.1)

 #  MAC[1..8]=maximum of the LARc[1..8];  8 values (see table 4.1)

 #  MAC[1..8]=minimum of the LARc[1..8];  8 values (see table 4.1)

 */

 void codlar( int2 LARc[], int2 LAR[] )

 {

   int i;

   int2 temp;

 /*

 # Computation for quantizing and coding the LAR[1..8]

 #

 #    |== FOR i=1 to 8:

 #    |    temp = mult( A[i], LAR[i] );

 #    |    temp = add( temp, B[i] );

 #    |    temp = add( temp, 256 );      for rounding

 #    |    LARc[i] = temp >> 9;

 #    |

 #    | Check if LARc[i] lies between MIN and MAX

 #    |    IF ( LARc[i] > MAC[i] ) THEN LARc[i] = MAC[i];

 #    |    IF ( LARc[i] < MIC[i] ) THEN LARc[i] = MIC[i];

 #    |    LARc[i] = sub( LARc[i], MIC[i] ); / See note below /

 #    |== NEXT i:

 #

 # NOTE: The equation is used to make all the LARc[i] positive.

 */

   for ( i = 1; i <= 8; i++ ) {

 	int j = i-1;

     temp = mult( A[j], LAR[j] );

     temp = add( temp, B[j] );

     temp = add( temp, 256 ); /* for rounding */

     temp = shr( temp, 9 );

     /* Check if LARc[i] lies between MIN and MAX */

     if ( sub( temp, MAC[j] ) > 0 )

       LARc[j] = sub( MAC[j], MIC[j] );

     else if ( sub( temp, MIC[j] ) < 0 )

       LARc[j] = 0;

     else

       LARc[j] = sub( temp, MIC[j] );

   }

 }

 /*

 #  4.2.8 Decoding of the coded Log.-Area Ratios

 #

 #  This procedure requires for efficient implementation two variables.

 #

 #  INVA[1..8]=integer((32768*8)/(real_A[1..8]);    8 values (table 4.2)

 #  MIC[1..8]=minimum value of the LARc[1..8];      8 values (table 4.2)

 */

 void declar( int2 LARpp[], int2 LARc[] )

 {

   int i;

   int2 temp1;

   int2 temp2;

 /*

 # Compute the LARpp[1..8].

 #

 #    |== FOR i=1 to 8:

 #    |    temp1 = add( LARc[i], MIC[i] ) << 10; /See note below/

 #    |    temp2 = B[i] << 1;

 #    |    temp1 = sub( temp1, temp2 );

 #    |    temp1 = mult_r( INVA[i], temp1 );

 #    |    LARpp[i] = add( temp1, temp1 );

 #    |== NEXT i:

 #

 # NOTE: The addition of MIC[i] is used to restore the sign of LARc[i].

 */

   for ( i = 1; i <= 8; i++ ) {

 	int j = i-1;

     temp1 = shl( add( LARc[j], MIC[j] ), 10 );

     temp2 = shl( B[j], 1 );

     temp1 = sub( temp1, temp2 );

     temp1 = mult_r( INVA[j], temp1 );

     LARpp[j] = add( temp1, temp1 );

   }

 }

 /*

 #  4.2.9. Computation of the quantized reflection coefficients

 #

 #  Within each frame of 160 anallyzed speech samples the short term

 #  analysissss and synthesis filters operate with four different sets of

 #  coefficients, derived from the previous set of decoded 

 #  LARs(LARpp(j-1)) and the actual set of decoded LARs (LARpp(j)).

 #

 # 4.2.9.1 Interpolation of the LARpp[1..8] to get LARp[1..8]

 */

 void cparc1( int2 LARp[], int2 LARpp_prev[], int2 LARpp[] )

 {

   int i;

   int2 temp;

 /*

 #    FOR k_start=0 to k_end = 12.

 #         

 #    |==== FOR i=1 to 8:

 #    |         LARp[i] = add( ( LARpp(j-1)[i] >> 2 ) ,( LARpp[i] >> 2 ) );

 #    |         LARp[i] = add( LARp[i], ( LARpp(j-1)[i] >> 1 ) );

 #    |==== NEXT i:

 */

   /* k_start=0 to k_end=12 */

   for ( i = 1; i <= 8; i++ ) {

 	int j = i-1;

     temp = add( shr( LARpp_prev[j], 2 ), shr( LARpp[j], 2 ) );

     LARp[j] = add( temp, shr( LARpp_prev[j], 1 ) );

   }

 }

 void cparc2( int2 LARp[], int2 LARpp_prev[], int2 LARpp[] )

 {

   int i;

 /*

 #    FOR k_start=13 to k_end = 26.

 #    |==== FOR i=1 to 8:

 #    |         LARp[i] = add( ( LARpp(j-1)[i] >> 1 ), ( LARpp[i] >> 1 ) );

 #    |==== NEXT i:

 */

   /* k_start=13 to k_end=26 */

   for (i=1; i <= 8; i++) {

 	int j = i-1;

     LARp[j] = add( shr( LARpp_prev[j], 1 ), shr( LARpp[j], 1 ) );

   }

 }

 void cparc3( int2 LARp[], int2 LARpp_prev[], int2 LARpp[] )

 {

   int i;

   int2 temp;

 /*

 #    FOR k_start=27 to k_end = 39.

 #    |==== FOR i=1 to 8:

 #    |         LARp[i] = add( ( LARpp(j-1)[i] >> 2 ), ( LARpp[i] >> 2 ) );

 #    |         LARp[i] = add( LARp[i], ( LARpp[i] >> 1 ) );

 #    |==== NEXT i:

 */

   /* k_start=27 to k_end=39 */

   for ( i = 1; i <= 8; i++ ) {

 	int j = i-1;

     temp = add( shr( LARpp_prev[j], 2 ), shr( LARpp[j], 2 ) );

     LARp[j] = add( temp, shr( LARpp[j], 1 ) );

   }

 }

 void cparc4( int2 LARp[], int2 LARpp_prev[], int2 LARpp[] )

 {

   int i;

 /*

 #    FOR k_start=40 to k_end = 159.

 #    |==== FOR i=1 to 8:

 #    |         LARp[i] = LARpp[i];

 #    |==== NEXT i:

 */

   /* k_start=40 to k_end=159 */

   for ( i = 1; i <= 8; i++ ) {

 	int j = i-1;

     LARp[j] = LARpp[j];

     /* note new LARs saved here for next frame */

     LARpp_prev[j] = LARpp[j];

   }

 }

 /*

 #  4.2.9.2 Computation of the rp[] from the interpolated LARp[]

 #

 #  The input of this procedure is the interpolated LARp[1..8] array. The

 #  reflection coefficients, rp[i], are used in the analysis filter and in

 #  the synthesis filter.

 */

 void crp( int2 rp[], int2 LARp[] )

 {

   int i;

   int2 temp;

 /*

 #    |== FOR i=1 to 8:

 #    |    temp = abs( LARp[i] );

 #    |    IF ( temp < 11059 ) THEN temp = temp << 1;

 #    |         ELSE IF ( temp < 20070 ) THEN temp = add( temp, 11059 );

 #    |              ELSE temp = add( ( temp >> 2 ), 26112 );

 #    |    rp[i] = temp;

 #    |    IF ( LARp[i] < 0 ) THEN rp[i] = sub( 0, rp[i] );

 #    |== NEXT i:

 */

   for (i=1; i <= 8; i++) {

 	int j = i-1;

     temp = abs_s( LARp[j] );

     if ( sub( temp, 11059 ) < 0 )

       temp = shl( temp, 1 );

     else if ( sub( temp, 20070 ) < 0 )

       temp = add( temp, 11059 );

     else

       temp = add( shr( temp, 2 ), 26112 );

     if ( LARp[j] < 0 )

       rp[j] = negate( temp );

     else

       rp[j] = temp;

   }

 }

 /*

 #  4.2.10. Short term analysis filtering

 #

 #  This procedure computes the short term residual d[..] to be fed

 #  to the RPE-LTP loop from s[..] signal and from the local rp[..]

 #  array (quantized reflection coefficients). As the call of this

 #  procedure can be done in many ways (see the interpolation of the LAR

 #  coefficients), it is assumed that the computation begins with index

 #  k_start (for arrays d[..] and s[..]) and stops with index k_end

 #  (k_start and k_end are defined in 4.2.9.1): This procedure also need

 #  to keep the array u[0..7] in memory for each call.

 #

 #  Keep the array u[0..7] in memory.

 #  Initial value: u[0..7]=0;

 */

 void invfil( CGSM610FR_Encoder* aEncoder, int2 d[], int2 s[], int2 rp[], int k_start, int k_end )

 {

   //ALEX//extern int2 u[];

   int k, i;

   int2 temp;

   int2 sav;

   int2 di;

 /*

 #    |== FOR k=k_start to k_end:

 #    |    di = s[k];

 #    |    sav = di;

 #    |==== FOR i=1 to 8:

 #    |         temp = add( u[i], mult_r( rp[i], di ) );

 #    |         di = add( di, mult_r( rp[i], u[i] ) );

 #    |         u[i] = sav;

 #    |         sav = temp;

 #    |==== NEXT i:

 #    |    d[k] = di;

 #    |== NEXT k:

 */

   for ( k = k_start; k <= k_end; k++ ) {

     di = s[k];

     sav = di;

     for ( i = 1; i <= 8; i++ ) {

 	  int j = i-1;

       temp = add( aEncoder->u[j], mult_r( rp[j], di ) );

       di = add( di, mult_r( rp[j], aEncoder->u[j] ) );

       aEncoder->u[j] = sav;

       sav = temp;

     }

     d[k] = di;

   }

 }

 /*

 #  4.2.11. Calculation of the LTP parameters

 #

 #  This procedure computes the LTP gain (bc) and the LTP lag (Nc) for

 #  the long term analysis filter. This is deone by calculating a maximum

 #  of the cross-correlation function between the current sub-segment

 #  short term residual signal d[0..39] (output of the short term 

 #  analysis filter; for each sub-segment of the RPE-LTP analysis) and the

 #  previous reconstructed short term residual signal dp[-120..-1]. A

 #  dynamic scaling must be performed to avoid overflow.

 # 

 #  Initial value: dp[-120..-1]=0;

 */

 void ltpcomp( CGSM610FR_Encoder* aEncoder, int2 *Nc, int2 *bc, int2 d[], int k_start )

 {

   int k, i;

   int2 lambda;

   int2 temp;

   int2 scal;

   int2 dmax;

   int4 L_max;

   int2 wt[40]; /* scaled residual, original cannot be destroyed */

   int4 L_result;

   int4 L_power;

   int2 R;

   int2 S;

 /*

 # Search of optimum scaling of d[kstart+0..39]

 #    dmax = 0;

 #    |== FOR k=0 to 39:

 #    |    temp = abs( d[k] );

 #    |    IF ( temp > dmax ) THEN dmax = temp;

 #    |== NEXT k:

 */

   dmax = 0;

   for (k=0; k <= 39; k++) {

     temp = abs_s( d[k+k_start] );

     if ( sub( temp, dmax ) > 0 )

       dmax = temp;

   }

 /*

 #    temp = 0;

 #    IF ( dmax == 0 ) THEN scal = 0;

 #         ELSE temp = norm( (long)dmax << 16 );

 #    IF ( temp > 6 ) THEN scal = 0;

 #         ELSE scal = sub( 6, temp );

 */  

   temp = 0;

   if ( dmax == 0 )

     scal = 0;

   else

     temp = norm_s( dmax );

   if ( sub( temp, 6 ) > 0 )

     scal = 0;

   else

     scal = sub( 6, temp );  /* 0 <= scal <= 6 */

 /*

 # Initialization of a working array wt[0..39]

 #    |== FOR k=0 to 39:

 #    |    wt[k] = d[k] >> scal;

 #    |== NEXT k:

 */

   for (k=0; k <= 39; k++)

     wt[k] = shr( d[k+k_start], scal ); /* scal >= 0 */

 /*

 # Search for the maximum of crosscorrelation and coding of the LTP lag.

 #    L_max = 0;

 #    Nc = 40;

 # 

 #    |== FOR lambda=40 to 120:

 #    |    L_result = 0;

 #    |==== FOR k=0 to 39:

 #    |         L_temp = L_mult( wt[k], dp[k-lambda] );

 #    |         L_result = L_add( L_temp, L_result );

 #    |==== NEXT k:

 #    |    IF ( L_result > L_max ) THEN

 #    |                                  |    Nc = lambda;

 #    |                                  |    L_max = L_result;

 #    |== NEXT lambda:

 */

   L_max = 0; /* 32 bits maximum */

   *Nc = 40; /* index for the maximum of cross correlation */

   for ( lambda = 40; lambda <= 120; lambda++ ) {

     L_result = 0;

     for (k = 0; k <= 39; k++)

 	  L_result = L_mac( L_result, wt[k], aEncoder->dp[k-lambda+120] );

   /* Borland C++ 3.1 error if -3 (386-instructions) are used.

   ** The code makes error (compared to (L_result > L_max)

   ** comparison. The problem disapears if the result of L_sub

   ** is stored to variable, e.g.

   **   if ( ( L_debug = L_sub( L_result, L_max ) ) > 0 ) {

   **

   ** Problem does not occur when -2 option (only 286

   ** instructions are used)

   **

   ** The problem exist e.g. with GSM full rate test seq01.ib

   */

     if ( L_sub( L_result, L_max ) > 0 ) {

 	 *Nc = lambda;

 	 L_max = L_result;

     }

   }

 /*

 # Re-scaling of L-max

 #    L_max = L_max >> sub( 6, scal );

 */

   L_max = L_shr( L_max, sub( 6, scal ) );

 /*

 # Initialization of a working array wt[0..39]

 #    |== FOR k=0 to 39:

 #    |    wt[k] = dp[k-Nc] >> 3;

 #    |== NEXT k:

 */

   for (k = 0; k <= 39; k++)

     wt[k] = shr( aEncoder->dp[k - *Nc + 120], 3 );

 /*

 # Compute the power of the reconstructed short term residual signal dp[..]

 #    L_power = 0;

 #    |== FOR k=0 to 39:

 #    |    L_temp = L_mult( wt[k], wt[k] );

 #    |    L_power = L_add( L_temp, L_power );

 #    |== NEXT k:

 */

   L_power = 0;

   for ( k = 0; k <= 39; k++ )

     L_power = L_mac( L_power, wt[k], wt[k] );

 /*

 # Normalization of L_max  and L_power

 #    IF ( L_max <= 0 ) THEN

 #                             | bc = 0;

 #                             | EXIT; /cont. with 4.2.12/

 */

   if ( L_max <= 0 ) {

     *bc = 0;

     return;

   }

 /*

 #    IF ( L_max >= L_power ) THEN

 #                             | bc = 3;

 #                             | EXIT; /cont. with 4.2.12/

 */

   if ( L_sub( L_max, L_power ) >= 0 ) {

     *bc = 3;

     return;

   }

 /*

 #    temp = norm( L_power );

 #    R = ( L_max << temp ) >> 16 );

 #    S = ( L_power << temp ) >> 16 );

 */

   temp = norm_l( L_power );

   R = extract_h( L_shl( L_max, temp ) );

   S = extract_h( L_shl( L_power, temp ) );

 /*

 # Coding of the LTP gain

 #

 # Table 4.3a must be used to obtain the level DLB[i] for the

 # quantization of the LTP gain b to get the coded version bc.

 #

 #    |== FOR bc=0 to 2:

 #    |    IF ( R <= mult( S, DLB[bc] ) ) THEN EXIT; /cont. with 4.2.12/

 #    |== NEXT bc:

 #

 #    bc = 3;

 */

   for ( i = 0; i <= 2; i++ ) {

     if ( sub( R, mult( S, DLB[i] ) ) <= 0 ) {

       *bc = int2 (i);

       return;

     }

   }

   *bc = 3;

 }

 /*

 #  4.2.12. Long term analysis filtering

 #

 #  In this part, we have to decode the bc parameter to compute the

 #  samples of the estimate dpp[0..39]. The decoding of bc needs the use

 #  of table 4.3b. The long term residual signal e[0..39] is then

 #  calculated to be fed to the RPE encoding section.

 */

 void ltpfil( CGSM610FR_Encoder* aEncoder, int2 e[], int2 dpp[], int2 d[], int2 bc, int2 Nc, int k_start )

 {

   int2 bp;

   int k;

 /*

 #    Decoding of the coded LTP gain.

 #       bp = QLB[bc];

 */

 	bp = QLB[bc];

 /*

 # Calculating the array e[0..39] and the array dpp[0..39]

 #

 #    |== FOR k=0 to 39:

 #    |         dpp[k] = mult_r( bp, dp[k-Nc] );

 #    |         e[k] = sub( d[k], dpp[k] );

 #    |== NEXT k:

 */

   for ( k = 0; k <= 39; k++ ) {

     dpp[k] = mult_r( bp, aEncoder->dp[k - Nc + 120] );

     e[k] = sub( d[k+k_start], dpp[k] );

   }

 }

 /*

 #  4.2.13. Weighting filter

 #

 #  The coefficients of teh weighting filter are stored in tables (see

 #  table 4.4). The following scaling is used:

 #

 #  H[0..10] = integer( real_H[0..10]*8192 );

 */

 void weight( int2 x[], int2 e[] )

 {

   int k, i;

   int2 wt[50];

   int4 L_result;

 /*

 # Initialization of a temporary working array wt[0..49]

 #    |== FOR k=0 to 4:

 #    |    wt[k] = 0;

 #    |== NEXT k:

 #

 #    |== FOR k=5 to 44:

 #    |    wt[k] = e[k-5];

 #    |== NEXT k:

 #

 #    |== FOR k=45 to 49:

 #    |    wt[k] = 0;

 #    |== NEXT k:

 */

   for ( k = 0; k <= 4; k++ ) 

     wt[k] = 0;

   for ( k = 5; k <= 44; k++ ) 

     wt[k] = e[k-5];

   for ( k = 45; k <= 49; k++ ) 

     wt[k] = 0;

 /*

 # Compute the signal x[0..39]

 #    |== FOR k=0 to 39:

 #    |    L_result = 8192;

 #    |==== FOR i=0 to 10:

 #    |         L_temp = L_mult( wt[k+i], H[i] );

 #    |         L_result = L_add( L_result, L_temp );

 #    |==== NEXT i:

 #    |    L_result = L_add( L_result, L_result ); /scaling L_result (x2)/

 #    |    L_result = L_add( L_result, L_result ); /scaling L_result (x4)/

 #    |    x[k] = (int)( L_result >> 16 );

 #    |== NEXT k:

 */

   for ( k = 0; k <= 39; k++ ) {

     L_result = L_deposit_l( 8192 );

     for ( i = 0; i <= 10; i++ )

       L_result = L_mac( L_result, wt[k+i], H[i] );

     /* scaling L_result (x4) and extract: scaling possible with new shift

      * because saturation is added L_shl

      *

      * L_result = L_add( L_result, L_result );

      * L_result = L_add( L_result, L_result );

      * x[k] = extract_h( L_result ); 

      @ Scaling can be done with L_shift because now shift has saturation

      */

     x[k] = extract_h( L_shl( L_result, 2 ) );

   }

 }

 /*

 #  4.2.14. RPE grid selection

 #

 #  The signal x[0..39] is used to select the RPE grid which is

 #  represented by Mc.

 */

 int2 gridsel( int2 xM[], int2 x[] )

 {

   int i, k;

   int2 temp1;

   int4 L_EM;

   int4 L_result;

   int2 Mc;

 /*

 #    EM = 0;

 #    Mc = 0;

 */

   L_EM = 0;

   Mc = 0;

 /*

 #    |== FOR m=0 to 3:

 #    |    L_result = 0;

 #    |==== FOR k=0 to 12:

 #    |         temp1 = x[i+(3*k)] >> 2;

 #    |         L_temp = L_mult( temp1, temp1 );

 #    |         L_result = L_add( L_temp, L_result );

 #    |==== NEXT i:

 #    |    IF ( L_result > L_max ) THEN

 #    |                                  |    Mc = m;

 #    |                                  |    EM = L_result;

 #    |== NEXT m:

 */  

   for ( i = 0; i <= 3; i++ ) {

     L_result = 0;

     for ( k = 0; k <= 12; k++ ) {

       temp1 = shr( x[i+(3*k)], 2 );

       L_result = L_mac( L_result, temp1, temp1 );

     }

     if ( L_sub( L_result, L_EM ) > 0 ) {

       Mc = int2 (i);

       L_EM = L_result;

     }

   }

 /*

 # Down-sampling by factor 3 to get the selected xM[0..12] RPE sequence

 #    |== FOR i=0 to 12:

 #    |    xM[k] = x[Mc+(3*i)];

 #    |== NEXT i:

 */

   for ( k = 0; k <= 12; k++ )

     xM[k] = x[Mc+(3*k)];

   return Mc;

 }

 /*

 # Compute exponent and mantissa of the decoded version of xmaxc

 #

 # Part of APCM and (subrogram apcm() InvAPCM (iapcm())

 */

 void expman( int2 *Exp, int2 *mant, int2 xmaxc )

 {

   int i;

 /*

 # Compute exponent and mantissa of the decoded version of xmaxc.

 #

 #    exp = 0;

 #    IF ( xmaxc > 15 ) THEN exp = sub( ( xmaxc >> 3 ), 1 );

 #    mant = sub( xmaxc, ( exp << 3 ) );

 */

   *Exp = 0;

   if ( sub( xmaxc, 15 ) > 0 )

     *Exp = sub( shr( xmaxc, 3 ), 1 );

   *mant = sub( xmaxc, shl( *Exp, 3 ) );

 /*

 # Normalize mantissa 0 <= mant <= 7.

 #    IF ( mant == 0 ) THEN    |    exp = -4;

 #                             |    mant = 15 ;

 #    ELSE | itest = 0;

 #         |== FOR i=0 to 2:

 #         |    IF ( mant > 7 ) THEN itest = 1;

 #         |    IF ( itest == 0 ) THEN mant = add( ( mant << 1 ), 1 );

 #         |    IF ( itest == 0 ) THEN exp = sub( exp, 1 );

 #         |== NEXT i:

 */

   if ( *mant == 0 ) {

     *Exp = -4;

     *mant = 15 ;

   }

   else {

     for ( i = 0; i <= 2; i++ ) {

       if ( sub( *mant, 7 ) > 0 )

 	break;

       else {

 	*mant = add( shl( *mant, 1 ), 1 );

 	*Exp = sub( *Exp, 1 );

       }

     }

   }

 /*

 #    mant = sub( mant, 8 );

 */

   *mant = sub( *mant, 8 );

 }

 int2 quantize_xmax( int2 xmax )

 {

   int i;

   int2 Exp;

   int2 temp;

   int2 itest;

 /*

 # Quantizing and coding of xmax to get xmaxc.

 #    exp = 0;

 #    temp = xmax >> 9;

 #    itest = 0;

 #    |== FOR i=0 to 5:

 #    |    IF ( temp <= 0 ) THEN itest = 1;

 #    |    temp = temp >> 1;

 #    |    IF ( itest == 0 ) THEN exp = add( exp, 1 )  ;

 #    |== NEXT i:

 */

   Exp = 0;

   temp = shr( xmax, 9 );

   itest = 0;

   for ( i = 0; i <= 5; i++ ) {

     if ( temp <= 0 )

       itest = 1;

     temp = shr( temp, 1 );

     if ( itest == 0 )

       Exp = add( Exp, 1 )  ;

   }

 /*

 #    temp = add( exp, 5 );

 #    xmaxc = add( ( xmax >> temp ), ( exp << 3 ) );

 */

   temp = add( Exp, 5 );

   return ( add( shr( xmax, temp ), shl( Exp, 3 ) ) ); /* xmaxc */

 }

 /*

 #  4.2.15. APCM quantization of the selected RPE sequence

 #

 #  Keep in memory exp and mant for the following inverse APCM quantizer.

 *

 * return unquantzed xmax for SID computation

 */

 int2 apcm( int2 *xmaxc, int2 xM[], int2 xMc[], int2 *Exp, int2 *mant )

 {

   int k;

   int2 temp;

   int2 temp1;

   int2 temp2;

   int2 temp3;

   int2 xmax;

 /*

 # Find the maximum absolute value of xM[0..12].

 #    xmax = 0;

 #    |== FOR k=0 to 12:

 #    |    temp = abs( xM[k] );

 #    |    IF ( temp > xmax ) THEN xmax = temp;

 #    |== NEXT i:

 */

   xmax = 0;

   for ( k = 0; k <= 12; k++ ) {

     temp = abs_s( xM[k] );

      if ( sub( temp, xmax ) > 0 )

        xmax = temp;

   }

   /*

    * quantization of xmax moved to function because it is used

    * also in comfort noise generation

    */

   *xmaxc = quantize_xmax( xmax );

   expman( Exp, mant, *xmaxc ); /* compute exp. and mant. */

 /*

 # Quantizing and coding of the xM[0..12] RPE sequence to get the xMc[0..12]

 #

 # This computation uses the fact that the decoded version of xmaxc can

 # be calculated by using the exponent and mantissa part of xmaxc

 # (logarithmic table).

 #

 # So, this method avoids any division and uses only scaling of the RPE

 # samples by a function of the exponent. A direct multiplication by the

 # inverse of the mantissa (NRFAC[0..7] found in table 4.5) gives the 3

 # bit coded version xMc[0..12} of the RPE samples.

 #

 # Direct computation of xMc[0..12] using table 4.5.

 #    temp1 = sub( 6, exp );   /normalization by the exponent/

 #    temp2 = NRFAC[mant];     /see table 4.5 (inverse mantissa)/

 #    |== FOR k=0 to 12:

 #    |    xM[k] = xM[k] << temp1;

 #    |    xM[k] = mult( xM[k], temp2 );

 #    |    xMc[k] = add( ( xM[k] >> 12 ), 4 );     / See note below/

 #    |== NEXT i:

 #

 # NOTE: This equation is used to make all the xMx[i] positive.

 */

   temp1 = sub( 6, *Exp );

   temp2 = NRFAC[*mant];

   for ( k = 0; k <= 12; k++ )  {

     temp3 = shl( xM[k], temp1 );

     temp3 = mult( temp3, temp2 );

     xMc[k] = add( shr( temp3, 12 ), 4 );

   }

   return xmax;

 }

 /*

 #  4.2.16. APCM inverse quantization

 #

 #  This part is for decoding the RPE sequence of coded xMc[0..12] samples

 #  to obtain the xMp[0..12] array. Table 4.6 is used to get the mantissa

 #  of xmaxc (FAC[0..7]).

 */

 void iapcm( int2 xMp[], int2 xMc[], int2 Exp, int2 mant )

 {

   //ALEX//extern int2 FAC[];

   int k;

   int2 temp;

   int2 temp1;

   int2 temp2;

   int2 temp3;

 /*

 #    temp1 = FAC[mant];       /See 4.2.15 for mant/

 #    temp2 = sub( 6, exp );   /See 4.2.15 for exp/

 #    temp3 = 1 << sub( temp2, 1 );

 */

   temp1 = FAC[mant];

   temp2 = sub( 6, Exp );

   temp3 = shl( 1, sub( temp2, 1 ) );

 /*

 #    |== FOR k=0 to 12:

 #    |    temp = sub( ( xMc[k] << 1 ), 7 );  /See note below/

 #    |    temp = temp << 12;

 #    |    temp = mult_r( temp1, temp );

 #    |    temp = add( temp, temp3 );

 #    |    xMp[k] = temp >> temp2;

 #    |== NEXT i:

 #

 # NOTE: This subtraction is used to restore the sign of xMc[i].

 */

   for ( k = 0; k <= 12; k++ ) {

     temp = sub( shl( xMc[k], 1 ), 7 );

     temp = shl( temp, 12 );

     temp = mult_r( temp1, temp );

     temp = add( temp, temp3 );

     xMp[k] = shr( temp, temp2 );

   }

 }

 /*

 #  4.2.17. RPE grid positioning

 #

 #  This procedure computes the reconstructed long term residual signal

 #  ep[0..39] for the LTP analysis filter. The inputs are the Mc which is

 #  the grid position selection and the xMp[0..12] decoded RPE samples

 #  which are upsampled by factor of 3 by inserting zero values.

 */

 void gridpos( int2 ep[], int2 xMp[], int2 Mc )

 {

   int k;

 /*

 #    |== FOR k=0 to 39:

 #    |    ep[k] = 0;

 #    |== NEXT k:

 */

   for ( k = 0; k <= 39; k++ ) 

     ep[k] = 0;

 /*

 #    |== FOR i=0 to 12:

 #    |    ep[Mc + (3*k)] = xMp[k];

 #    |== NEXT i:

 */

   for ( k = 0; k <= 12; k++ ) 

     ep[Mc + (3*k)] = xMp[k];

 }

 /*

 #  4.2.18. Update of the reconstructed short term residual signal dp[]

 #

 #  Keep the array dp[-120..-1] in memory for the next sub-segment.

 #  Initial value: dp[-120..-1]=0;

 */

 void ltpupd( CGSM610FR_Encoder* aEncoder, int2 dpp[], int2 ep[] )

 {

   int i;

 /*

 #    |== FOR k=0 to 79:

 #    |    dp[-120+k] = dp[-80+k];

 #    |== NEXT k:

 */

   for (i = 0; i <= 79; i++) 

     aEncoder->dp[-120+i+120] = aEncoder->dp[-80+i+120];

 /*

 #    |== FOR k=0 to 39:

 #    |    dp[-40+k] = add( ep[k], dpp[k] );

 #    |== NEXT k:

 */

   for (i = 0; i <= 39; i++) 

     aEncoder->dp[-40+i+120] = add( ep[i], dpp[i] );

 }

 /*

 #  4.3.2. Long term synthesis filtering

 #

 #  Keep the nrp value for the next sub-segment.

 #  Initial value: nrp=40;

 #

 #  Keep the array drp[-120..-1] for the next sub-segment.

 #  Initial value: drp[-120..-1]=0;

 */

 void ltpsyn( CGSM610FR_Decoder* aDecoder, int2 erp[], int2 wt[], int2 bcr, int2 Ncr )

 {

   int k, i;

   int2 drpp;

   int2 Nr;

   int2 brp;

 /*

 # Check the limits of Nr

 #    Nr = Ncr;

 #    IF ( Ncr < 40 ) THEN Nr = nrp;

 #    IF ( Ncr > 120 ) THEN Nr = nrp;

 #    nrp = Nr;

 */

   if ( sub( Ncr, 40 ) < 0 )

     Nr = aDecoder->nrp;

   else if ( sub( Ncr, 120 ) > 0 )

     Nr = aDecoder->nrp;

   else

     Nr = Ncr;

   aDecoder->nrp = Nr;

 /*

 # Decoding of the LTP gain bcr.

 #    brp = QLB[bcr];

 */

   brp = QLB[bcr];

 /*

 # Computation of the reconstructed short term residual signal drp[0..39].

 #    |== FOR k=0 to 39:

 #    |    drpp = mult_r( brp, drp[k-Nr] );

 #    |    drp[k+120] = add( erp[k], drpp );

 #    |== NEXT k:

 */

   for ( k = 0; k <= 39; k++ ) { 

     drpp = mult_r( brp, aDecoder->drp[k-Nr+120] );

     wt[k] = add( erp[k], drpp );

   }

 /*

 # Update of the reconstructed short term residual signal drp[-1..-120]

 #    |== FOR k=0 to 119:

 #    |    drp[-120+k] = drp[-80+k];

 #    |== NEXT k:

 */

   for ( i = 0; i < 80; i++ )

     aDecoder->drp[i] = aDecoder->drp[40+i];

   for ( i = 0; i < 40; i++ )

     aDecoder->drp[i+80] = wt[i];

 }

 /*

 #  4.3.4. Short term synthesis filtering section

 #

 #  This procedure uses the drp[0..39] signal and produces the sr[0..159]

 #  signal which is the output of the short term synthesis filter. For

 #  ease of explanation, a temporary array wt[0..159] is used.

 #

 #  Initialization of the array wt[0..159].

 #

 #  For the first sub-segment in a frame:

 #    |== FOR k=0 to 39:

 #    |    wt[k] = drp[k];

 #    |== NEXT k:

 #

 #  For the second sub-segment in a frame:

 #    |== FOR k=0 to 39:

 #    |    wt[40+k] = drp[k];

 #    |== NEXT k:

 #

 #  For the third sub-segment in a frame:

 #    |== FOR k=0 to 39:

 #    |    wt[80+k] = drp[k];

 #    |== NEXT k:

 #

 #  For the fourth sub-segment in a frame:

 #    |== FOR k=0 to 39:

 #    |    wt[120+k] = drp[k];

 #    |== NEXT k:

 #

 #  As the call of the short term synthesis filter procedure can be done

 #  in many ways (see the interpolation of the LAR coefficient), it is

 #  assumed that the computation begins with index k_start (for arrays

 #  wt[..] and sr[..]) and stops with index k_end (k_start and k_end are

 #  defined in 4.2.9.1). The procedure also needs to keep the array

 #  v[0..8] in memory between calls.

 #

 #  Keep the array v[0..8] in memory for the next call.

 #  Initial value: v[0..8]=0;

 */

 void synfil( CGSM610FR_Decoder* aDecoder, int2 sr[], int2 wt[], int2 rrp[], int k_start, int k_end )

 {

   int k;

   int i;

   int2 sri;

 /*

 #    |== FOR k=k_start to k_end:

 #    |    sri = wt[k];

 #    |==== FOR i=1 to 8:

 #    |         sri = sub( sri, mult_r( rrp[9-i], v[8-i] ) );

 #    |         v[9-i] = add( v[8-i], mult_r( rrp[9-i], sri ) ) ;

 #    |==== NEXT i:

 #    |    sr[k] = sri;

 #    |    v[0] = sri;

 #    |== NEXT k:

 */

   for ( k = k_start; k <= k_end; k++ ) {

     sri = wt[k];

     for ( i = 1; i <= 8; i++ ) {

 	  int j = i+1;

       sri = sub( sri, mult_r( rrp[9-j], aDecoder->v[8-i] ) );

       aDecoder->v[9-i] = add( aDecoder->v[8-i], mult_r( rrp[9-j], sri ) ) ;

     }

     sr[k] = sri;

     aDecoder->v[0] = sri;

   }

 }

 /*

 ** 4.3.5., 4.3.6., 4.3.7. Postprocessing

 **

 ** Combined deemphasis, upscaling and truncation

 */

 void postpr( CGSM610FR_Decoder* aDecoder, int2 srop[], int2 sr[] )

 {

   int k;

 /*

 # 4.3.5. Deemphasis filtering

 #

 # Keep msr in memory for the next frame.

 # Initial value: msr=0;

 */

 /*

 #    |== FOR k=0 to 159:

 #    |    temp = add( sr[k], mult_r( msr, 28180 ) );

 #    |    msr = temp;

 #    |    sro[k] = msr;

 #    |== NEXT k:

 */

 /*

 # 4.3.6 Upscaling of the output signal

 */

 /*

 #    |== FOR k=0 to 159:

 #    |    srop[k] = add( sro[k], sro[k] );

 #    |== NEXT k:

 */

 /*

 # 4.3.7. Truncation of the output variable

 */

 /*

 #    |== FOR k=0 to 159:

 #    |    srop[k] = srop[k] >> 3;

 #    |    srop[k] = srop[k] << 3;

 #    |== NEXT k:

 */

   for ( k = 0; k <= 159; k++ ) {

     aDecoder->msr = add( sr[k], mult_r( aDecoder->msr, 28180 ) );

     srop[k] = int2 (shl( aDecoder->msr, 1 ) & 0xfff8);

   }

 }