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