/******************************************************************

       iLBC Speech Coder ANSI-C Source Code

       StateConstructW.c

       Copyright (C) The Internet Society (2004).
       All Rights Reserved.

   ******************************************************************/

#include <math.h>
#include <string.h>

#include "iLBC_define.h"
#include "constants.h"
#include "filter.h"

   /*----------------------------------------------------------------*
    *  decoding of the start state
    *---------------------------------------------------------------*/

void StateConstructW(int idxForMax,     /* (i) 6-bit index for the quantization of
                                           max amplitude */
  int *idxVec,                  /* (i) vector of quantization indexes */
  float *syntDenum,             /* (i) synthesis filter denumerator */
  float *out,                   /* (o) the decoded state vector */
  int len                       /* (i) length of a state vector */
  )
{
  float maxVal, tmpbuf[LPC_FILTERORDER + 2 * STATE_LEN], *tmp,
    numerator[LPC_FILTERORDER + 1];
  float foutbuf[LPC_FILTERORDER + 2 * STATE_LEN], *fout;
  int k, tmpi;

  /* decoding of the maximum value */

  maxVal = state_frgqTbl[idxForMax];
  maxVal = (float) pow(10, maxVal) / (float) 4.5;

  /* initialization of buffers and coefficients */

  memset(tmpbuf, 0, LPC_FILTERORDER * sizeof(float));
  memset(foutbuf, 0, LPC_FILTERORDER * sizeof(float));
  for (k = 0; k < LPC_FILTERORDER; k++) {
    numerator[k] = syntDenum[LPC_FILTERORDER - k];
  }
  numerator[LPC_FILTERORDER] = syntDenum[0];
  tmp = &tmpbuf[LPC_FILTERORDER];
  fout = &foutbuf[LPC_FILTERORDER];

  /* decoding of the sample values */

  for (k = 0; k < len; k++) {
    tmpi = len - 1 - k;
    /* maxVal = 1/scal */
    tmp[k] = maxVal * state_sq3Tbl[idxVec[tmpi]];
  }

  /* circular convolution with all-pass filter */

  memset(tmp + len, 0, len * sizeof(float));
  ZeroPoleFilter(tmp, numerator, syntDenum, 2 * len,
    LPC_FILTERORDER, fout);
  for (k = 0; k < len; k++) {
    out[k] = fout[len - 1 - k] + fout[2 * len - 1 - k];
  }
}