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