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

       iLBC Speech Coder ANSI-C Source Code

       getCBvec.c

       Copyright (C) The Internet Society (2004).

       All Rights Reserved.

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

   #include "iLBC_define.h"

   #include "constants.h"

   #include <string.h>

   /*----------------------------------------------------------------*

    *  Construct codebook vector for given index.

    *---------------------------------------------------------------*/

   void getCBvec(

       float *cbvec,   /* (o) Constructed codebook vector */

       float *mem,     /* (i) Codebook buffer */

       int index,      /* (i) Codebook index */

       int lMem,       /* (i) Length of codebook buffer */

       int cbveclen/* (i) Codebook vector length */

   ){

       int j, k, n, memInd, sFilt;

       float tmpbuf[CB_MEML];

       int base_size;

       int ilow, ihigh;

       float alfa, alfa1;

       /* Determine size of codebook sections */

       base_size=lMem-cbveclen+1;

       if (cbveclen==SUBL) {

           base_size+=cbveclen/2;

       }

       /* No filter -> First codebook section */

       if (index<lMem-cbveclen+1) {

           /* first non-interpolated vectors */

           k=index+cbveclen;

           /* get vector */

           memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));

       } else if (index < base_size) {

           k=2*(index-(lMem-cbveclen+1))+cbveclen;

           ihigh=k/2;

           ilow=ihigh-5;

           /* Copy first noninterpolated part */

           memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));

           /* interpolation */

           alfa1=(float)0.2;

           alfa=0.0;

           for (j=ilow; j<ihigh; j++) {

               cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+

                   alfa*mem[lMem-k+j];

               alfa+=alfa1;

           }

           /* Copy second noninterpolated part */

           memcpy(cbvec+ihigh, mem+lMem-k+ihigh,

               (cbveclen-ihigh)*sizeof(float));

       }

       /* Higher codebook section based on filtering */

       else {

           /* first non-interpolated vectors */

           if (index-base_size<lMem-cbveclen+1) {

               float tempbuff2[CB_MEML+CB_FILTERLEN+1];

               float *pos;

               float *pp, *pp1;

               memset(tempbuff2, 0,

                   CB_HALFFILTERLEN*sizeof(float));

               memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,

                   lMem*sizeof(float));

               memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,

                   (CB_HALFFILTERLEN+1)*sizeof(float));

               k=index-base_size+cbveclen;

               sFilt=lMem-k;

               memInd=sFilt+1-CB_HALFFILTERLEN;

               /* do filtering */

               pos=cbvec;

               memset(pos, 0, cbveclen*sizeof(float));

               for (n=0; n<cbveclen; n++) {

                   pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN];

                   pp1=&cbfiltersTbl[CB_FILTERLEN-1];

                   for (j=0; j<CB_FILTERLEN; j++) {

                       (*pos)+=(*pp++)*(*pp1--);

                   }

                   pos++;

               }

           }

           /* interpolated vectors */

           else {

               float tempbuff2[CB_MEML+CB_FILTERLEN+1];

               float *pos;

               float *pp, *pp1;

               int i;

               memset(tempbuff2, 0,

                   CB_HALFFILTERLEN*sizeof(float));

               memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,

                   lMem*sizeof(float));

               memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,

                   (CB_HALFFILTERLEN+1)*sizeof(float));

               k=2*(index-base_size-

                   (lMem-cbveclen+1))+cbveclen;

               sFilt=lMem-k;

               memInd=sFilt+1-CB_HALFFILTERLEN;

               /* do filtering */

               pos=&tmpbuf[sFilt];

               memset(pos, 0, k*sizeof(float));

               for (i=0; i<k; i++) {

                   pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN];

                   pp1=&cbfiltersTbl[CB_FILTERLEN-1];

                   for (j=0; j<CB_FILTERLEN; j++) {

                       (*pos)+=(*pp++)*(*pp1--);

                   }

                   pos++;

               }

               ihigh=k/2;

               ilow=ihigh-5;

               /* Copy first noninterpolated part */

               memcpy(cbvec, tmpbuf+lMem-k/2,

                   ilow*sizeof(float));

               /* interpolation */

               alfa1=(float)0.2;

               alfa=0.0;

               for (j=ilow; j<ihigh; j++) {

                   cbvec[j]=((float)1.0-alfa)*

                       tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j];

                   alfa+=alfa1;

               }

               /* Copy second noninterpolated part */

               memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh,

                   (cbveclen-ihigh)*sizeof(float));

           }

       }

   }