FCL/sf/os/mm: comparison mmlibs/mmfw/Codecs/Src/Gsm610CodecCommon/rpeltp.cpp

equal deleted inserted replaced

--1:000000000000
+:40261b775718
+// 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 Bug 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);
+}
+}

changeset 0	40261b775718
child 31	ae0addfe117e