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