// 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

     */