codecs/ilbc/createCB.c

   1
   2
   3
   4 /******************************************************************
   5
   6     iLBC Speech Coder ANSI-C Source Code
   7
   8     createCB.c
   9
  10     Copyright (C) The Internet Society (2004).
  11     All Rights Reserved.
  12
  13 ******************************************************************/
  14
  15 #include "iLBC_define.h"
  16 #include "createCB.h"
  17 #include "constants.h"
  18 #include <string.h>
  19 #include <math.h>
  20
  21 /*----------------------------------------------------------------*
  22  *  Construct an additional codebook vector by filtering the
  23  *  initial codebook buffer. This vector is then used to expand
  24  *  the codebook with an additional section.
  25  *---------------------------------------------------------------*/
  26
  27 void filteredCBvecs(
  28     float *cbvectors,   /* (o) Codebook vectors for the
  29                                higher section */
  30     float *mem,         /* (i) Buffer to create codebook
  31                                vector from */
  32     int lMem        /* (i) Length of buffer */
  33 ){
  34     int j, k;
  35     float *pp, *pp1;
  36     float tempbuff2[CB_MEML+CB_FILTERLEN];
  37     float *pos;
  38
  39     memset(tempbuff2, 0, (CB_HALFFILTERLEN-1)*sizeof(float));
  40     memcpy(&tempbuff2[CB_HALFFILTERLEN-1], mem, lMem*sizeof(float));
  41     memset(&tempbuff2[lMem+CB_HALFFILTERLEN-1], 0,
  42         (CB_HALFFILTERLEN+1)*sizeof(float));
  43
  44     /* Create codebook vector for higher section by filtering */
  45
  46     /* do filtering */
  47     pos=cbvectors;
  48     memset(pos, 0, lMem*sizeof(float));
  49     for (k=0; k<lMem; k++) {
  50         pp=&tempbuff2[k];
  51         pp1=&cbfiltersTbl[CB_FILTERLEN-1];
  52         for (j=0;j<CB_FILTERLEN;j++) {
  53             (*pos)+=(*pp++)*(*pp1--);
  54         }
  55         pos++;
  56     }
  57 }
  58
  59
  60
  61 /*----------------------------------------------------------------*
  62  *  Search the augmented part of the codebook to find the best
  63  *  measure.
  64  *----------------------------------------------------------------*/
  65
  66 void searchAugmentedCB(
  67     int low,        /* (i) Start index for the search */
  68     int high,           /* (i) End index for the search */
  69     int stage,          /* (i) Current stage */
  70     int startIndex,     /* (i) Codebook index for the first
  71                                aug vector */
  72     float *target,      /* (i) Target vector for encoding */
  73     float *buffer,      /* (i) Pointer to the end of the buffer for
  74                                augmented codebook construction */
  75     float *max_measure, /* (i/o) Currently maximum measure */
  76     int *best_index,/* (o) Currently the best index */
  77     float *gain,    /* (o) Currently the best gain */
  78     float *energy,      /* (o) Energy of augmented codebook
  79                                vectors */
  80     float *invenergy/* (o) Inv energy of augmented codebook
  81                                vectors */
  82 ) {
  83     int icount, ilow, j, tmpIndex;
  84     float *pp, *ppo, *ppi, *ppe, crossDot, alfa;
  85     float weighted, measure, nrjRecursive;
  86     float ftmp;
  87
  88     /* Compute the energy for the first (low-5)
  89        noninterpolated samples */
  90     nrjRecursive = (float) 0.0;
  91     pp = buffer - low + 1;
  92     for (j=0; j<(low-5); j++) {
  93         nrjRecursive += ( (*pp)*(*pp) );
  94         pp++;
  95     }
  96     ppe = buffer - low;
  97
  98
  99     for (icount=low; icount<=high; icount++) {
 100
 101         /* Index of the codebook vector used for retrieving
 102            energy values */
 103         tmpIndex = startIndex+icount-20;
 104
 105         ilow = icount-4;
 106
 107         /* Update the energy recursively to save complexity */
 108         nrjRecursive = nrjRecursive + (*ppe)*(*ppe);
 109         ppe--;
 110         energy[tmpIndex] = nrjRecursive;
 111
 112         /* Compute cross dot product for the first (low-5)
 113            samples */
 114         crossDot = (float) 0.0;
 115
 116
 117         pp = buffer-icount;
 118         for (j=0; j<ilow; j++) {
 119             crossDot += target[j]*(*pp++);
 120         }
 121
 122         /* interpolation */
 123         alfa = (float) 0.2;
 124         ppo = buffer-4;
 125         ppi = buffer-icount-4;
 126         for (j=ilow; j<icount; j++) {
 127             weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
 128             ppo++;
 129             ppi++;
 130             energy[tmpIndex] += weighted*weighted;
 131             crossDot += target[j]*weighted;
 132             alfa += (float)0.2;
 133         }
 134
 135         /* Compute energy and cross dot product for the
 136            remaining samples */
 137         pp = buffer - icount;
 138         for (j=icount; j<SUBL; j++) {
 139             energy[tmpIndex] += (*pp)*(*pp);
 140             crossDot += target[j]*(*pp++);
 141         }
 142
 143         if (energy[tmpIndex]>0.0) {
 144             invenergy[tmpIndex]=(float)1.0/(energy[tmpIndex]+EPS);
 145         } else {
 146             invenergy[tmpIndex] = (float) 0.0;
 147         }
 148
 149         if (stage==0) {
 150             measure = (float)-10000000.0;
 151
 152             if (crossDot > 0.0) {
 153                 measure = crossDot*crossDot*invenergy[tmpIndex];
 154             }
 155         }
 156         else {
 157             measure = crossDot*crossDot*invenergy[tmpIndex];
 158         }
 159
 160         /* check if measure is better */
 161         ftmp = crossDot*invenergy[tmpIndex];
 162
 163         if ((measure>*max_measure) && (fabs(ftmp)<CB_MAXGAIN)) {
 164             *best_index = tmpIndex;
 165             *max_measure = measure;
 166             *gain = ftmp;
 167         }
 168     }
 169 }
 170
 171
 172
 173
 174 /*----------------------------------------------------------------*
 175  *  Recreate a specific codebook vector from the augmented part.
 176  *
 177  *----------------------------------------------------------------*/
 178
 179 void createAugmentedVec(
 180     int index,      /* (i) Index for the augmented vector
 181                            to be created */
 182     float *buffer,  /* (i) Pointer to the end of the buffer for
 183                            augmented codebook construction */
 184     float *cbVec/* (o) The construced codebook vector */
 185 ) {
 186     int ilow, j;
 187     float *pp, *ppo, *ppi, alfa, alfa1, weighted;
 188
 189     ilow = index-5;
 190
 191     /* copy the first noninterpolated part */
 192
 193     pp = buffer-index;
 194     memcpy(cbVec,pp,sizeof(float)*index);
 195
 196     /* interpolation */
 197
 198     alfa1 = (float)0.2;
 199     alfa = 0.0;
 200     ppo = buffer-5;
 201     ppi = buffer-index-5;
 202     for (j=ilow; j<index; j++) {
 203         weighted = ((float)1.0-alfa)*(*ppo)+alfa*(*ppi);
 204         ppo++;
 205         ppi++;
 206         cbVec[j] = weighted;
 207         alfa += alfa1;
 208     }
 209
 210     /* copy the second noninterpolated part */
 211
 212     pp = buffer - index;
 213     memcpy(cbVec+index,pp,sizeof(float)*(SUBL-index));
 214 }
 215
 216