// 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 "rpeltp.h"

 #include "codec.h"

 #include "gsm610fr.h"

 /*

 ** LPC analysis part of the RPE-LTP-coder

 **

 ** Input:

 **      sop[0..159]

 **              unprocessed sample frame 

 ** Output:

 **      d[0..159]

 **              residual 

 **      LARc[0..7]

 **              coded reflection coefficients 

 **      *SP_flag:

 **              decision of tx DTX (boolean)

 **      *VAD_flag:

 **              decision of VAD (boolean)

 **

 ** Return value:

 **      None

 */

 void LPC_analysis(CGSM610FR_Encoder* aEncoder, int2 ibuf[], struct codes *ecodes)

 {

   int4 L_ACF[9];

   int2 LAR[8]; /* used for r[], LAR[], LARpp */

   int2 rp[8]; /* used for LARp[], rp[] */

 //  int2 scalauto; /* returned from autoc to be used by vad */

   prepr( aEncoder, ibuf, ibuf ); /* sof <- so */

   preemp( aEncoder, ibuf, ibuf ); /* s <- sof */

 //  scalauto = autoc( L_ACF, ibuf ); /* L_ACF <- , s <- s */

   autoc( L_ACF, ibuf ); /* L_ACF <- , s <- s */

   /*

   ** VAD decision could be computed here when L_ACF and scalauto are available.

   ** In current version vad is executed after LAR computation

   */

   schur( LAR, L_ACF ); /* r <- L_ACF */

   larcomp( LAR, LAR ); /* LAR <- r */

   codlar( ecodes->LARc, LAR ); /* LARc <- LAR */

   declar( LAR, ecodes->LARc ); /* LARpp <- LARc */

   cparc1( rp, aEncoder->LARpp_prev, LAR ); /* LARp <- LARpp_prev, LARpp */

   crp( rp, rp ); /* rp <- LARp */

   invfil( aEncoder, ibuf, ibuf, rp, 0, 12 ); /* d <- s */

   cparc2( rp, aEncoder->LARpp_prev, LAR ); /* LARp <- LARpp_prev, LARpp */

   crp( rp, rp ); /* rp <- LARp */

   invfil( aEncoder, ibuf, ibuf, rp, 13, 26 ); /* d <- s */

   cparc3( rp, aEncoder->LARpp_prev, LAR ); /* LARp <- LARpp_prev, LARpp */

   crp( rp, rp ); /* rp <- LARp */

   invfil( aEncoder, ibuf, ibuf, rp, 27, 39 ); /* d <- s*/

   cparc4( rp, aEncoder->LARpp_prev, LAR ); /* LARp <- LARpp_prev, LARpp */

   crp( rp, rp ); /* rp <- LARp */

   invfil( aEncoder, ibuf, ibuf, rp, 40, 159 ); /* d <- s */

   return;

 }

 /*

 ** Encoding of the residual signal of the LPC analysis filter

 ** Input:

 **

 ** d[k_start..k_start+39]

 **      LPC residual (output of LPC analysis filter)

 **

 ** Output:

 **

 ** bc, Nc

 **      encoded LTP parameters (gain and lag)

 ** xmaxc

 **      block maximum of the encoded subframe.

 ** xMc[0..12]

 **              coded normalized RPE pulses

 **

 ** return xmax for SID computation

 */

 int2 residual_encoder( CGSM610FR_Encoder* aEncoder, int sf_nro, int2 d[], struct sfcodes *sfc )

 {

   int k_start;

   int2 xmax; /* return value */

   /* Note: d[] is used also for for x[] and e[] */

   int2 xM[13]; /* used for xM[], xMp[] */

   /* xM[] is required simultaneously with xMc because LTP

    * also decodes xMc

    */

   int2 dpp[40]; /* required simultaneously with ep[] that is

 		 * stored into d[]

 		 */

   int2 Exp;

   int2 mant;

   k_start = sf_nro * 40;

   ltpcomp( aEncoder, &(sfc->Nc), &(sfc->bc), d, k_start );

   ltpfil( aEncoder, &d[k_start], dpp, d, sfc->bc, sfc->Nc, k_start ); /* e, dpp <- d */

   weight( &d[k_start], &d[k_start] ); /* x <- e */

   sfc->Mc = gridsel( xM, &d[k_start] ); /* xM <- x */

   /*

   ** quatize residual and store unquantized xmax for SID

   ** computation

   */

   xmax = apcm( &(sfc->xmaxc), xM, sfc->xMc, &Exp, &mant);

   /* EXP, mant computed int APCM */

   iapcm( xM, sfc->xMc, Exp, mant ); /* xMp <- xMc */

   gridpos( &d[k_start], xM, sfc->Mc ); /* ep <- xMc,Mc */

   ltpupd( aEncoder, dpp, &d[k_start] ); /* dp <- dpp, x */

   return( xmax );

 }

 /*

 ** Decoding of the coded LPC-residual

 **

 ** Input:

 ** xmaxcr

 **      coded block maxmimum

 ** xMcr[0..12]

 **      coded normalized RPE pulses

 **

 ** Output:

 ** drp[k_start..k_start+39]

 **      decoded LPC residual (input signal for LPC-synthesis filter)

 */

 void residual_decoder(CGSM610FR_Decoder* aDecoder, int sf_nro, struct sfcodes *sfc, int2 wt[])

 {

   int k_start;

   int2 EXP;

   int2 mant;

   int2 xMrp[13];

   int2 erp[40];

   k_start = sf_nro * 40;

   /* in decoder EXP ja mant must be computed from xmaxcr */

   expman( &EXP, &mant, sfc->xmaxc ); /* EXP, mant <- xmaxc */

   iapcm( xMrp, sfc->xMc, EXP, mant ); /* xMrp <- xMc */

   gridpos( erp, xMrp, sfc->Mc ); /* erp <- xMc,Mc */

   ltpsyn( aDecoder, erp, &wt[k_start], sfc->bc, sfc->Nc );

 }

 /*

 ** LPC synthesis part of the RPE-LTP-coder

 **

 ** Input:

 **      LARcr[0..7]

 **              coded reflection coefficients

 **      wt[0..159]

 **              decoded residual

 **

 ** Output:

 **      srop[0..159]

 **              decoded speech

 */

 void LPC_synthesis(CGSM610FR_Decoder* aDecoder, struct codes *dcodes, int2 wt[], int2 obuf[])

 {

   int2 LARr[8]; /* used for LARr[], LARpp */

   int2 rrp[8]; /* used for LARp[], rrp[] */

   declar(LARr, dcodes->LARc); /* LARrpp <- LARc */

   cparc1( rrp, aDecoder->LARrpp_prev, LARr ); /* LARp <- LARrpp_prev, LARr */

   crp( rrp, rrp ); /* rrp <- LARp */

   synfil( aDecoder, obuf, wt, rrp, 0, 12 ); /* sr <- wt */

   cparc2( rrp, aDecoder->LARrpp_prev, LARr ); /* LARp <- LARrpp_prev, LARr */

   crp( rrp, rrp ); /* rrp <- LARp */

   synfil( aDecoder, obuf, wt, rrp, 13, 26 ); /* sr <- wt */

   cparc3( rrp, aDecoder->LARrpp_prev, LARr ); /* LARp <- LARrpp_prev, LARr */

   crp( rrp, rrp ); /* rrp <- LARp */

   synfil( aDecoder, obuf, wt, rrp, 27, 39 ); /* sr <- wt */

   cparc4( rrp, aDecoder->LARrpp_prev, LARr ); /* LARp <- LARrpp_prev, LARr */

   crp( rrp, rrp ); /* rrp <- LARp */

   synfil( aDecoder, obuf, wt, rrp, 40, 159 ); /* sr <- wt */

   postpr( aDecoder, obuf, obuf );

   /* combines deemphasis, upscaling and truncation */

 }

 /*

 ** RPE-LTP Encoder

 **

 ** void RPELTP_encoder(CGSM610FR_Encoder* aEncoder, int2 ibuf[], struct codes *ecodes)

 **

 ** Input:

 **      ibuf[0..159]

 **              Original speech to be coded

 **

 ** Output:

 **      ecodes

 **              encoded speech stored as codewords

 */

 void RPELTP_encoder(CGSM610FR_Encoder* aEncoder, int2 ibuf[], struct codes *ecodes)

 {

   int i;

 //  int2 xmax[4]; /* collect unquantized xmax data for dtx */	

   LPC_analysis( aEncoder, ibuf, ecodes );

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

 //    xmax[i] = residual_encoder( aEncoder, i, ibuf, &(ecodes->sfc[i]) );	

     residual_encoder( aEncoder, i, ibuf, &(ecodes->sfc[i]) );

 }

 /*

 ** RPE-LTP Decoder

 **

 ** void RPELTP_decoder(struct codes *dcodes, int2 obuf[])

 ** Input:

 **      dcodes

 **              encoded speech stored as codewords to be decoded

 **

 ** Output:

 **      obuf[0..159]

 **              Decoded speech

 */

 void RPELTP_decoder(CGSM610FR_Decoder* aDecoder, struct codes *dcodes, int2 obuf[])

 {

   int i;

   dcodes->LARc[0] &= 0x7fff; /* VAD flag in sequences */

   dcodes->LARc[1] &= 0x7fff; /* SP flag in sequences */

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

     residual_decoder(aDecoder, i, &(dcodes->sfc[i]), obuf); /* -> wt */

   LPC_synthesis(aDecoder, dcodes, obuf, obuf); /* wt -> srop */

 }