cbsearch.c

this the source code of addio compression standard CELP. Also, it is optimizied for the execution sp

/**************************************************************************
*
* ROUTINE
*               cbsearch
*
* FUNCTION
*               find optimal MSPE excitation code word
*
* SYNOPSIS
*               subroutine cbsearch(l, v)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       l               int     i       length of vectors
*       v(l)            float   o       optimum excitation segment found
*
*   external
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       cbgbits         int     i       code book gain bit allocation
*       cbindex         int     i/o     code book index
*       gindex          int     i/o     gain index
*       ncsize          int     i       code book size
*       no              int     i       filter order  predictor
*       h[]             float   i       impulse response
*       x[];            float   i       code book
*       cbgtype[];      char    i       code book gain quantizer type
******************************************************************************/

#include "ccsub.h"
#include <math.h>
extern float  eng_cb[MAXNCSIZE], h[MAXLP];
extern int  cbindex, gindex, ncsize;
extern float x[MAXCODE], e0[MAXLP];
cbsearch(l, v)
int l;
register float v[];
{
  register int i, codenumber, codeword;
  register float emax;
  float  gain[MAXNCSIZE], err[MAXNCSIZE], gainencode();
  float  y[MAXLP];
  int    j, len=5;
  register float temp;
/*
    for (i = 0; i < l-len; i++)
    {
      y[i] = 0.0;
      for (j = i; j < i+len; j++)
      {
          y[i] += h[j-i] * e0[j];
      }
    }
*/
    for (i = l-len; i < l; i++)
    {
      y[i] = 0.0;
      for (j = i; j <l; j++)
      {
          y[i] += h[j-i] * e0[j];
      }
    }

#define FLIT(K)              temp = h[0]*e0[K];      \
                             temp += h[1]*e0[K+1];   \
                             temp += h[2]*e0[K+2];   \
                             temp += h[3]*e0[K+3];   \
                             temp += h[4]*e0[K+4];   \
                             y[K]  = temp;


        FLIT(0);  FLIT(1);  FLIT(2);  FLIT(3);  FLIT(4);  FLIT(5);
        FLIT(6);  FLIT(7);  FLIT(8);  FLIT(9);  FLIT(10); FLIT(11);
        FLIT(12); FLIT(13); FLIT(14); FLIT(15); FLIT(16); FLIT(17);
        FLIT(18); FLIT(19); FLIT(20); FLIT(21); FLIT(22); FLIT(23);
        FLIT(24); FLIT(25); FLIT(26); FLIT(27); FLIT(28); FLIT(29);
        FLIT(30); FLIT(31); FLIT(32); FLIT(33); FLIT(34); FLIT(35);
        FLIT(36); FLIT(37); FLIT(38); FLIT(39); FLIT(40); FLIT(41);
        FLIT(42); FLIT(43); FLIT(44); FLIT(45); FLIT(46); FLIT(47);
        FLIT(48); FLIT(49); FLIT(50); FLIT(51); FLIT(52); FLIT(53);
        FLIT(54);


  movefr(l, y, e0);
  
  cor0_255(err);   /*   0  ~~~~ 255   */
  cor256_511(err);  /*   256 ~~~~ 511  */
  codenumber = MAXNCSIZE - 1;
  cbindex = 1;
  gain[0] =  *err/eng_cb[codenumber];
  emax = *err * gain[0];
  codenumber--;
  for (i = 1; i < ncsize; i++)
  {
    gain[i] =  err[i]/eng_cb[codenumber];
    err[i] = err[i] * gain[i];
    if (err[i] > emax)
    {
      emax = err[i];
      cbindex = i + 1;
    }
     codenumber--;
  }

  codeword = 2*(MAXNCSIZE - cbindex);

      gain[cbindex-1] = gainencode(gain[cbindex-1], &gindex);
    
  /*		*scale selected code word vector -> excitation array	*/
  
  for (i = 0; i < l; i++)
    v[i] = gain[cbindex - 1] * x[i + codeword];
}