getCBvec.c

Go to the documentation of this file.

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