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



    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 "StateConstructW.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];
    }
}