开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
acelp_ca.c
资源名称：g729a_c_linux.rar　[点击查看]
上传用户：zhouyunkk
上传日期：2013-01-10
资源大小：59k
文件大小：26k
源码类别：

语音压缩

开发平台：

C/C++

acelp_ca.c：源码内容
  1. /*
  2.    ITU-T G.729 Annex C - Reference C code for floating point
  3.                          implementation of G.729 Annex A
  4.                          Version 1.01 of 15.September.98
  5. */
  7. /*
  8. ----------------------------------------------------------------------
  9.                     COPYRIGHT NOTICE
  10. ----------------------------------------------------------------------
  11.    ITU-T G.729 Annex C ANSI C source code
  12.    Copyright (C) 1998, AT&T, France Telecom, NTT, University of
  13.    Sherbrooke.  All rights reserved.
  15. ----------------------------------------------------------------------
  16. */
  18. /*
  19.  File : ACELP_CA.C
  20.  Used for the floating point version of G.729A only
  21.  (not for G.729 main body)
  22. */
  24. /*---------------------------------------------------------------------------*
  25.  *  Function  ACELP_code_A()                                                 *
  26.  *  ~~~~~~~~~~~~~~~~~~~~~~~~                                                 *
  27.  *   Find Algebraic codebook for G.729A                                      *
  28.  *--------------------------------------------------------------------------*/
  30. /*  L_SUBFR   -> Lenght of subframe.                                        */
  31. /*  NB_POS    -> Number of positios for each pulse.                         */
  32. /*  STEP      -> Step betweem position of the same pulse.                   */
  33. /*  MSIZE     -> Size of vectors for cross-correlation between two pulses.  */
  35. #include "typedef.h"
  36. #include "ld8a.h"
  38. /* local routines definition */
  40. static void cor_h(
  41.      FLOAT *H,          /* (i) :Impulse response of filters */
  42.      FLOAT *rr          /* (o) :Correlations of H[]         */
  43. );
  44. static int d4i40_17_fast(/*(o) : Index of pulses positions.               */
  45.   FLOAT dn[],           /* (i) : Correlations between h[] and Xn[].       */
  46.   FLOAT *rr,            /* (i) : Correlations of impulse response h[].    */
  47.   FLOAT h[],            /* (i) : Impulse response of filters.             */
  48.   FLOAT cod[],          /* (o) : Selected algebraic codeword.             */
  49.   FLOAT y[],            /* (o) : Filtered algebraic codeword.             */
  50.   int  *sign            /* (o) : Signs of 4 pulses.                       */
  51. );
  53.  /*-----------------------------------------------------------------*
  54.   * Main ACELP function.                                            *
  55.   *-----------------------------------------------------------------*/
  57. int ACELP_code_A(       /* (o) :index of pulses positions    */
  58.   FLOAT x[],            /* (i) :Target vector                */
  59.   FLOAT h[],            /* (i) :Inpulse response of filters  */
  60.   int T0,               /* (i) :Pitch lag                    */
  61.   FLOAT pitch_sharp,    /* (i) :Last quantized pitch gain    */
  62.   FLOAT code[],         /* (o) :Innovative codebook          */
  63.   FLOAT y[],            /* (o) :Filtered innovative codebook */
  64.   int *sign             /* (o) :Signs of 4 pulses            */
  65. )
  66. {
  67.   int i, index;
  68.   static FLOAT Dn[L_SUBFR]; /* "static" to avoid stack overflow on PC */
  69.   static FLOAT rr[DIM_RR];  /* "static" to avoid stack overflow on PC */
  71.  /*-----------------------------------------------------------------*
  72.   * Include fixed-gain pitch contribution into impulse resp. h[]    *
  73.   * Find correlations of h[] needed for the codebook search.        *
  74.   *-----------------------------------------------------------------*/
  76.   if (T0 < L_SUBFR)
  77.      for (i = T0; i < L_SUBFR; i++)
  78.         h[i] += pitch_sharp * h[i-T0];
  80.   cor_h(h, rr);
  82.  /*-----------------------------------------------------------------*
  83.   * Compute correlation of target vector with impulse response.     *
  84.   *-----------------------------------------------------------------*/
  86.   cor_h_x(h, x, Dn);
  88.  /*-----------------------------------------------------------------*
  89.   * Find innovative codebook.                                       *
  90.   *-----------------------------------------------------------------*/
  91.   index = d4i40_17_fast(Dn, rr, h, code, y, sign);
  93.  /*-----------------------------------------------------------------*
  94.   * Compute innovation vector gain.                                 *
  95.   * Include fixed-gain pitch contribution into code[].              *
  96.   *-----------------------------------------------------------------*/
  98.   if(T0 < L_SUBFR)
  99.      for (i = T0; i < L_SUBFR; i++)
  100.        code[i] += pitch_sharp*code[i-T0];
  102.   return index;
  103. }
  106. /*--------------------------------------------------------------------------*
  107.  *  Function  cor_h()                                                       *
  108.  *  ~~~~~~~~~~~~~~~~~                                                       *
  109.  * Compute  correlations of h[]  needed for the codebook search.            *
  110.  *--------------------------------------------------------------------------*/
  112. static void cor_h(
  113.   FLOAT *h,         /* (i) :Impulse response of filters */
  114.   FLOAT *rr         /* (o) :Correlations of H[]         */
  115. )
  116. {
  117.   FLOAT *rri0i0, *rri1i1, *rri2i2, *rri3i3, *rri4i4;
  118.   FLOAT *rri0i1, *rri0i2, *rri0i3, *rri0i4;
  119.   FLOAT *rri1i2, *rri1i3, *rri1i4;
  120.   FLOAT *rri2i3, *rri2i4;
  122.   FLOAT *p0, *p1, *p2, *p3, *p4;
  124.   FLOAT *ptr_hd, *ptr_hf, *ptr_h1, *ptr_h2;
  125.   FLOAT cor;
  126.   int i, k, ldec, l_fin_sup, l_fin_inf;
  128.  /*------------------------------------------------------------*
  129.   * Compute rri0i0[], rri1i1[], rri2i2[], rri3i3 and rri4i4[]  *
  130.   *------------------------------------------------------------*/
  131.   /* Init pointers */
  132.   rri0i0 = rr;
  133.   rri1i1 = rri0i0 + NB_POS;
  134.   rri2i2 = rri1i1 + NB_POS;
  135.   rri3i3 = rri2i2 + NB_POS;
  136.   rri4i4 = rri3i3 + NB_POS;
  137.   rri0i1 = rri4i4 + NB_POS;
  138.   rri0i2 = rri0i1 + MSIZE;
  139.   rri0i3 = rri0i2 + MSIZE;
  140.   rri0i4 = rri0i3 + MSIZE;
  141.   rri1i2 = rri0i4 + MSIZE;
  142.   rri1i3 = rri1i2 + MSIZE;
  143.   rri1i4 = rri1i3 + MSIZE;
  144.   rri2i3 = rri1i4 + MSIZE;
  145.   rri2i4 = rri2i3 + MSIZE;
  147.   p0 = rri0i0 + NB_POS-1;   /* Init pointers to last position of rrixix[] */
  148.   p1 = rri1i1 + NB_POS-1;
  149.   p2 = rri2i2 + NB_POS-1;
  150.   p3 = rri3i3 + NB_POS-1;
  151.   p4 = rri4i4 + NB_POS-1;
  153.   ptr_h1 = h;
  154.   cor    = (F)0.0;
  155.   for(i=0;  i<NB_POS; i++)
  156.   {
  157.     cor += *ptr_h1 * *ptr_h1; ptr_h1++;
  158.     *p4-- = cor;
  160.     cor += *ptr_h1 * *ptr_h1; ptr_h1++;
  161.     *p3-- = cor;
  163.     cor += *ptr_h1 * *ptr_h1; ptr_h1++;
  164.     *p2-- = cor;
  166.     cor += *ptr_h1 * *ptr_h1; ptr_h1++;
  167.     *p1-- = cor;
  169.     cor += *ptr_h1 * *ptr_h1; ptr_h1++;
  170.     *p0-- = cor;
  171.   }
  173.  /*-----------------------------------------------------------------*
  174.   * Compute elements of: rri2i3[], rri1i2[], rri0i1[] and rri0i4[]  *
  175.   *-----------------------------------------------------------------*/
  177.   l_fin_sup = MSIZE-1;
  178.   l_fin_inf = l_fin_sup-1;
  179.   ldec = NB_POS+1;
  181.   ptr_hd = h;
  182.   ptr_hf = ptr_hd + 1;
  184.   for(k=0; k<NB_POS; k++) {
  186.           p3 = rri2i3 + l_fin_sup;
  187.           p2 = rri1i2 + l_fin_sup;
  188.           p1 = rri0i1 + l_fin_sup;
  189.           p0 = rri0i4 + l_fin_inf;
  190.           cor = (F)0.0;
  191.           ptr_h1 = ptr_hd;
  192.           ptr_h2 =  ptr_hf;
  194.           for(i=k+1; i<NB_POS; i++ ) {
  196.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  197.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  198.                   *p3 = cor;
  200.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  201.                   *p2 = cor;
  203.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  204.                   *p1 = cor;
  206.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  207.                   *p0 = cor;
  209.                   p3 -= ldec;
  210.                   p2 -= ldec;
  211.                   p1 -= ldec;
  212.                   p0 -= ldec;
  213.           }
  214.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  215.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  216.           *p3 = cor;
  218.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  219.           *p2 = cor;
  221.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  222.           *p1 = cor;
  224.           l_fin_sup -= NB_POS;
  225.           l_fin_inf--;
  226.           ptr_hf += STEP;
  227.   }
  229.  /*---------------------------------------------------------------------*
  230.   * Compute elements of: rri2i4[], rri1i3[], rri0i2[], rri1i4[], rri0i3 *
  231.   *---------------------------------------------------------------------*/
  233.   ptr_hd = h;
  234.   ptr_hf = ptr_hd + 2;
  235.   l_fin_sup = MSIZE-1;
  236.   l_fin_inf = l_fin_sup-1;
  237.   for(k=0; k<NB_POS; k++) {
  239.           p4 = rri2i4 + l_fin_sup;
  240.           p3 = rri1i3 + l_fin_sup;
  241.           p2 = rri0i2 + l_fin_sup;
  242.           p1 = rri1i4 + l_fin_inf;
  243.           p0 = rri0i3 + l_fin_inf;
  245.           cor = (F)0.0;
  246.           ptr_h1 = ptr_hd;
  247.           ptr_h2 =  ptr_hf;
  248.           for(i=k+1; i<NB_POS; i++ ) {
  250.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  251.                   *p4 = cor;
  253.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  254.                   *p3 = cor;
  256.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  257.                   *p2 = cor;
  259.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  260.                   *p1 = cor;
  262.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  263.                   *p0 = cor;
  265.                   p4 -= ldec;
  266.                   p3 -= ldec;
  267.                   p2 -= ldec;
  268.                   p1 -= ldec;
  269.                   p0 -= ldec;
  270.           }
  271.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  272.           *p4 = cor;
  274.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  275.           *p3 = cor;
  277.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  278.           *p2 = cor;
  280.           l_fin_sup -= NB_POS;
  281.           l_fin_inf--;
  282.           ptr_hf += STEP;
  283.   }
  285.  /*----------------------------------------------------------------------*
  286.   * Compute elements of: rri1i4[], rri0i3[], rri2i4[], rri1i3[], rri0i2  *
  287.   *----------------------------------------------------------------------*/
  289.   ptr_hd = h;
  290.   ptr_hf = ptr_hd + 3;
  291.   l_fin_sup = MSIZE-1;
  292.   l_fin_inf = l_fin_sup-1;
  293.   for(k=0; k<NB_POS; k++) {
  295.           p4 = rri1i4 + l_fin_sup;
  296.           p3 = rri0i3 + l_fin_sup;
  297.           p2 = rri2i4 + l_fin_inf;
  298.           p1 = rri1i3 + l_fin_inf;
  299.           p0 = rri0i2 + l_fin_inf;
  301.           ptr_h1 = ptr_hd;
  302.           ptr_h2 =  ptr_hf;
  303.           cor = (F)0.0;
  304.           for(i=k+1; i<NB_POS; i++ ) {
  306.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  307.                   *p4 = cor;
  309.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  310.                   *p3 = cor;
  312.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  313.                   *p2 = cor;
  315.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  316.                   *p1 = cor;
  318.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  319.                   *p0 = cor;
  321.                   p4 -= ldec;
  322.                   p3 -= ldec;
  323.                   p2 -= ldec;
  324.                   p1 -= ldec;
  325.                   p0 -= ldec;
  326.           }
  327.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  328.           *p4 = cor;
  330.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  331.           *p3 = cor;
  333.           l_fin_sup -= NB_POS;
  334.           l_fin_inf--;
  335.           ptr_hf += STEP;
  336.   }
  338.  /*----------------------------------------------------------------------*
  339.   * Compute elements of: rri0i4[], rri2i3[], rri1i2[], rri0i1[]          *
  340.   *----------------------------------------------------------------------*/
  342.   ptr_hd = h;
  343.   ptr_hf = ptr_hd + 4;
  344.   l_fin_sup = MSIZE-1;
  345.   l_fin_inf = l_fin_sup-1;
  346.   for(k=0; k<NB_POS; k++) {
  348.           p3 = rri0i4 + l_fin_sup;
  349.           p2 = rri2i3 + l_fin_inf;
  350.           p1 = rri1i2 + l_fin_inf;
  351.           p0 = rri0i1 + l_fin_inf;
  353.           ptr_h1 = ptr_hd;
  354.           ptr_h2 =  ptr_hf;
  355.           cor = 0;
  356.           for(i=k+1; i<NB_POS; i++ ) {
  358.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  359.                   *p3 = cor;
  361.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  362.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  363.                   *p2 = cor;
  365.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  366.                   *p1 = cor;
  368.                   cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  369.                   *p0 = cor;
  371.                   p3 -= ldec;
  372.                   p2 -= ldec;
  373.                   p1 -= ldec;
  374.                   p0 -= ldec;
  375.           }
  376.           cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
  377.           *p3 = cor;
  379.           l_fin_sup -= NB_POS;
  380.           l_fin_inf--;
  381.           ptr_hf += STEP;
  382.   }
  383.   return;
  384. }
  387. /*------------------------------------------------------------------------*
  388.  * Function  d4i40_17_fast                                                *
  389.  *           ~~~~~~~~~                                                    *
  390.  * Algebraic codebook for G.729A.                                         *
  391.  *  -> 17 bits; 4 pulses in a frame of 40 samples                         *
  392.  *                                                                        *
  393.  *------------------------------------------------------------------------*
  394.  * The code length is 40, containing 4 nonzero pulses i0, i1, i2, i3.     *
  395.  * Each pulses can have 8 possible positions (positive or negative)       *
  396.  * except i3 that have 16 possible positions.                             *
  397.  *                                                                        *
  398.  * i0 (+-1) : 0, 5, 10, 15, 20, 25, 30, 35                                *
  399.  * i1 (+-1) : 1, 6, 11, 16, 21, 26, 31, 36                                *
  400.  * i2 (+-1) : 2, 7, 12, 17, 22, 27, 32, 37                                *
  401.  * i3 (+-1) : 3, 8, 13, 18, 23, 28, 33, 38                                *
  402.  *            4, 9, 14, 19, 24, 29, 34, 39                                *
  403.  *------------------------------------------------------------------------*/
  405. static int d4i40_17_fast(/*(o) : Index of pulses positions.               */
  406.   FLOAT dn[],           /* (i) : Correlations between h[] and Xn[].       */
  407.   FLOAT rr[],           /* (i) : Correlations of impulse response h[].    */
  408.   FLOAT h[],            /* (i) : Impulse response of filters.             */
  409.   FLOAT cod[],          /* (o) : Selected algebraic codeword.             */
  410.   FLOAT y[],            /* (o) : Filtered algebraic codeword.             */
  411.   int *sign             /* (o) : Signs of 4 pulses.                       */
  412. )
  413. {
  416.   int i0, i1, i2, i3, ip0, ip1, ip2, ip3;
  417.   int i, j, ix, iy, track, trk;
  418.   int prev_i0, i1_offset;
  419.   FLOAT psk, ps, ps0, ps1, ps2, sq, sq2;
  420.   FLOAT alpk, alp, max;
  421.   FLOAT s, alp0, alp1, alp2;
  422.   FLOAT *p0, *p1, *p2, *p3, *p4;
  424.   FLOAT sign_dn[L_SUBFR], sign_dn_inv[L_SUBFR], *psign;
  425.   FLOAT tmp_vect[NB_POS];
  427.   FLOAT *rri0i0, *rri1i1, *rri2i2, *rri3i3, *rri4i4;
  428.   FLOAT *rri0i1, *rri0i2, *rri0i3, *rri0i4;
  429.   FLOAT *rri1i2, *rri1i3, *rri1i4;
  430.   FLOAT *rri2i3, *rri2i4;
  432.   FLOAT  *ptr_rri0i3_i4;
  433.   FLOAT  *ptr_rri1i3_i4;
  434.   FLOAT  *ptr_rri2i3_i4;
  435.   FLOAT  *ptr_rri3i3_i4;
  437.      /* Init pointers */
  438.    rri0i0 = rr;
  439.    rri1i1 = rri0i0 + NB_POS;
  440.    rri2i2 = rri1i1 + NB_POS;
  441.    rri3i3 = rri2i2 + NB_POS;
  442.    rri4i4 = rri3i3 + NB_POS;
  443.    rri0i1 = rri4i4 + NB_POS;
  444.    rri0i2 = rri0i1 + MSIZE;
  445.    rri0i3 = rri0i2 + MSIZE;
  446.    rri0i4 = rri0i3 + MSIZE;
  447.    rri1i2 = rri0i4 + MSIZE;
  448.    rri1i3 = rri1i2 + MSIZE;
  449.    rri1i4 = rri1i3 + MSIZE;
  450.    rri2i3 = rri1i4 + MSIZE;
  451.    rri2i4 = rri2i3 + MSIZE;
  453.  /*-----------------------------------------------------------------------*
  454.   * Chose the sign of the impulse.                                        *
  455.   *-----------------------------------------------------------------------*/
  457.    for (i=0; i<L_SUBFR; i++)
  458.    {
  459.      if (dn[i] >= (F)0.0)
  460.      {
  461.        sign_dn[i] = (F)1.0;
  462.        sign_dn_inv[i] = (F)-1.0;
  463.      }
  464.      else
  465.      {
  466.        sign_dn[i] = (F)-1.0;
  467.        sign_dn_inv[i] = (F)1.0;
  468.        dn[i] = -dn[i];
  469.      }
  470.    }
  472.  /*-------------------------------------------------------------------*
  473.   * Modification of rrixiy[] to take signs into account.              *
  474.   *-------------------------------------------------------------------*/
  476.   p0 = rri0i1;
  477.   p1 = rri0i2;
  478.   p2 = rri0i3;
  479.   p3 = rri0i4;
  481.   for(i0=0; i0<L_SUBFR; i0+=STEP)
  482.   {
  483.     psign = sign_dn;
  484.     if (psign[i0] < 0.0) psign = sign_dn_inv;
  486.     for(i1=1; i1<L_SUBFR; i1+=STEP)
  487.     {
  488.       *p0 *= psign[i1];    p0++;
  489.       *p1 *= psign[i1+1];  p1++;
  490.       *p2 *= psign[i1+2];  p2++;
  491.       *p3 *= psign[i1+3];  p3++;
  492.     }
  493.   }
  495.   p0 = rri1i2;
  496.   p1 = rri1i3;
  497.   p2 = rri1i4;
  499.   for(i1=1; i1<L_SUBFR; i1+=STEP)
  500.   {
  501.     psign = sign_dn;
  502.     if (psign[i1] < 0.0) psign = sign_dn_inv;
  504.     for(i2=2; i2<L_SUBFR; i2+=STEP)
  505.     {
  506.       *p0 *= psign[i2];   p0++;
  507.       *p1 *= psign[i2+1]; p1++;
  508.       *p2 *= psign[i2+2]; p2++;
  509.     }
  510.   }
  512.   p0 = rri2i3;
  513.   p1 = rri2i4;
  515.   for(i2=2; i2<L_SUBFR; i2+=STEP)
  516.   {
  517.     psign = sign_dn;
  518.     if (psign[i2] < 0.0) psign = sign_dn_inv;
  520.     for(i3=3; i3<L_SUBFR; i3+=STEP)
  521.     {
  522.       *p0 *= psign[i3];   p0++;
  523.       *p1 *= psign[i3+1]; p1++;
  524.     }
  525.   }
  528.  /*-------------------------------------------------------------------*
  529.   * Search the optimum positions of the four pulses which maximize    *
  530.   *     square(correlation) / energy                                  *
  531.   *-------------------------------------------------------------------*/
  533.   psk = (F)-1.0;
  534.   alpk = (F)1.0;
  536.   ptr_rri0i3_i4 = rri0i3;
  537.   ptr_rri1i3_i4 = rri1i3;
  538.   ptr_rri2i3_i4 = rri2i3;
  539.   ptr_rri3i3_i4 = rri3i3;
  541.   /* search 2 times: track 3 and 4 */
  543.   for (track=3, trk=0; track<5; track++, trk++)
  544.   {
  545.    /*------------------------------------------------------------------*
  546.     * depth first search 3, phase A: track 2 and 3/4.                  *
  547.     *------------------------------------------------------------------*/
  549.     sq = (F)-1.0;
  550.     alp = (F)1.0;
  552.     /* i0 loop: 2 positions in track 2 */
  554.     prev_i0  = -1;
  556.     for (i=0; i<2; i++)
  557.     {
  558.       max = (F)-1.0;
  559.       /* search "dn[]" maximum position in track 2 */
  560.       for (j=2; j<L_SUBFR; j+=STEP)
  561.       {
  562.         if( ((dn[j] - max) > (F)0.0) && ((prev_i0-j) != 0) )
  563.         {
  564.           max = dn[j];
  565.           i0 = j;
  566.         }
  567.       }
  568.       prev_i0 = i0;
  570.       j = i0 / 5;        /* j = i0/5 */
  571.       p0 = rri2i2 + j;
  573.       ps1 = dn[i0];
  574.       alp1 = 0.5 * *p0;
  576.       /* i1 loop: 8 positions in track 2 */
  578.       p0 = ptr_rri2i3_i4 + (j<<3);
  579.       p1 = ptr_rri3i3_i4;
  581.       for (i1=track; i1<L_SUBFR; i1+=STEP)
  582.       {
  583.         ps2 = ps1 + dn[i1];
  584.         alp2 = alp1 + *p0++ + *p1++ * (F)0.5;
  585.         sq2 = ps2 * ps2;
  586.         s = alp*sq2 - sq * alp2;
  587.         if (s > (F)0.0)
  588.         {
  589.           sq = sq2;
  590.           ps = ps2;
  591.           alp = alp2;
  592.           ix = i0;
  593.           iy = i1;
  594.         }
  595.       }
  596.     }
  598.     i0 = ix;
  599.     i1 = iy;
  600.     i1_offset = (i1/5) <<3;           /* j = 8*(i1/5) */
  602.    /*------------------------------------------------------------------*
  603.     * depth first search 3, phase B: track 0 and 1.                    *
  604.     *------------------------------------------------------------------*/
  606.     ps0 = ps;
  607.     alp0 = alp;
  609.     sq = (F)-1.0;
  610.     alp = (F)1.0;
  612.     /* build vector for next loop to decrease complexity */
  614.     p0 = rri1i2 + i0/5;
  615.     p1 = ptr_rri1i3_i4 + i1/5;
  616.     p2 = rri1i1;
  617.     p3 = tmp_vect;
  619.     for (i3=1; i3<L_SUBFR; i3+=STEP)
  620.     {
  621.       *p3++ = *p0 + *p1 + *p2 * (F)0.5;
  622.       p0 += NB_POS; p1 += NB_POS; p2++;
  623.     }
  625.     /* i2 loop: 8 positions in track 0 */
  627.     p0 = rri0i2 + i0/5;
  628.     p1 = ptr_rri0i3_i4 + i1/5;
  629.     p2 = rri0i0;
  630.     p3 = rri0i1;
  632.     for (i2=0; i2<L_SUBFR; i2+=STEP)
  633.     {
  634.       ps1 = ps0 + dn[i2];
  636.       alp1 = alp0 + *p0 + *p1 + *p2 * (F)0.5;
  637.       p0 += NB_POS; p1 += NB_POS; p2++;
  639.       /* i3 loop: 8 positions in track 1 */
  641.       p4 = tmp_vect;
  643.       for (i3=1; i3<L_SUBFR; i3+=STEP)
  644.       {
  645.         ps2 = ps1 + dn[i3];
  647.         alp2 = alp1 + *p3++ + *p4++;
  649.         sq2 = ps2 * ps2;
  650.         s = alp*sq2 - sq * alp2;
  651.         if (s > 0.0)
  652.         {
  653.           sq = sq2;
  654.           alp = alp2;
  655.           ix = i2;
  656.           iy = i3;
  657.         }
  658.       }
  659.     }
  661.    /*----------------------------------------------------------------*
  662.     * depth first search 3: compare codevector with the best case.   *
  663.     *----------------------------------------------------------------*/
  665.     s = alpk*sq - psk * alp;
  666.     if (s > (F)0.0)
  667.     {
  668.       psk = sq;
  669.       alpk = alp;
  670.       ip2 = i0;
  671.       ip3 = i1;
  672.       ip0 = ix;
  673.       ip1 = iy;
  674.     }
  676.    /*------------------------------------------------------------------*
  677.     * depth first search 4, phase A: track 3 and 0.                    *
  678.     *------------------------------------------------------------------*/
  680.     sq = (F)-1.0;
  681.     alp = (F)1.0;
  683.     /* i0 loop: 2 positions in track 3/4 */
  685.     prev_i0  = -1;
  687.     for (i=0; i<2; i++)
  688.     {
  689.       max = (F)-1.0;
  690.       /* search "dn[]" maximum position in track 3/4 */
  691.       for (j=track; j<L_SUBFR; j+=STEP)
  692.       {
  693.         if( ((dn[j] - max) > 0) && ((prev_i0 -j) != 0) )
  694.         {
  695.           max = dn[j];
  696.           i0 = j;
  697.         }
  698.       }
  699.       prev_i0 = i0;
  701.       j = i0/5;
  702.       p0 = ptr_rri3i3_i4 + j;
  704.       ps1 = dn[i0];
  705.       alp1 = 0.5 * *p0;
  707.       /* i1 loop: 8 positions in track 0 */
  709.       p0 = ptr_rri0i3_i4 + j;
  710.       p1 = rri0i0;
  712.       for (i1=0; i1<L_SUBFR; i1+=STEP)
  713.       {
  714.         ps2 = ps1 + dn[i1];
  716.         alp2 = alp1 + *p0 + *p1 * (F)0.5;
  717.         p0 += NB_POS;
  718.         p1++;
  720.         sq2 = ps2 * ps2;
  721.         s = alp*sq2 - sq * alp2;
  722.         if (s > (F)0.0)
  723.         {
  724.           sq = sq2;
  725.           ps = ps2;
  726.           alp = alp2;
  727.           ix = i0;
  728.           iy = i1;
  729.         }
  730.       }
  731.     }
  733.     i0 = ix;
  734.     i1 = iy;
  735.     i1_offset = (i1/5) <<3;           /* j = 8*(i1/5) */
  737.    /*------------------------------------------------------------------*
  738.     * depth first search 4, phase B: track 1 and 2.                    *
  739.     *------------------------------------------------------------------*/
  741.     ps0 = ps;
  742.     alp0 = alp;
  744.     sq = (F)-1.0;
  745.     alp = (F)1.0;
  747.     /* build vector for next loop to decrease complexity */
  749.     p0 = ptr_rri2i3_i4 + i0/5;
  750.     p1 = rri0i2 + i1_offset;
  751.     p2 = rri2i2;
  752.     p3 = tmp_vect;
  754.     for (i3=2; i3<L_SUBFR; i3+=STEP)
  755.     {
  756.       *p3++ = *p0 + *p1 + *p2 * (F)0.5;
  757.       p0 += NB_POS; p1++; p2++;
  758.     }
  760.     /* i2 loop: 8 positions in track 1 */
  762.     p0 = ptr_rri1i3_i4 + i0/5;
  763.     p1 = rri0i1 + i1_offset;
  764.     p2 = rri1i1;
  765.     p3 = rri1i2;
  767.     for (i2=1; i2<L_SUBFR; i2+=STEP)
  768.     {
  769.       ps1 = ps0 + dn[i2];
  771.       alp1 = alp0 + *p0 + *p1 + *p2 * (F)0.5;
  772.       p0 += NB_POS; p1++; p2++;
  774.       /* i3 loop: 8 positions in track 2 */
  776.       p4 = tmp_vect;
  778.       for (i3=2; i3<L_SUBFR; i3+=STEP)
  779.       {
  780.         ps2 = ps1 + dn[i3];
  781.         alp2 = alp1 + *p3++ + *p4++;
  782.         sq2 = ps2 * ps2;
  783.         s = alp*sq2 - sq * alp2;
  784.         if (s > (F)0.0)
  785.         {
  786.           sq = sq2;
  787.           alp = alp2;
  788.           ix = i2;
  789.           iy = i3;
  790.         }
  791.       }
  792.     }
  794.    /*----------------------------------------------------------------*
  795.     * depth first search 1: compare codevector with the best case.   *
  796.     *----------------------------------------------------------------*/
  798.     s = alpk*sq - psk*alp;
  799.     if (s > (F)0.0)
  800.     {
  801.       psk = sq;
  802.       alpk = alp;
  803.       ip3 = i0;
  804.       ip0 = i1;
  805.       ip1 = ix;
  806.       ip2 = iy;
  807.     }
  808.   ptr_rri0i3_i4 = rri0i4;
  809.   ptr_rri1i3_i4 = rri1i4;
  810.   ptr_rri2i3_i4 = rri2i4;
  811.   ptr_rri3i3_i4 = rri4i4;
  813.   }
  816.  /* Set the sign of impulses */
  818.  i0 = (int)sign_dn[ip0];
  819.  i1 = (int)sign_dn[ip1];
  820.  i2 = (int)sign_dn[ip2];
  821.  i3 = (int)sign_dn[ip3];
  823.  /* Find the codeword corresponding to the selected positions */
  826.  for(i=0; i<L_SUBFR; i++) {
  827.    cod[i] = (F)0.0;
  828.  }
  830.  cod[ip0] = (F)i0;
  831.  cod[ip1] = (F)i1;
  832.  cod[ip2] = (F)i2;
  833.  cod[ip3] = (F)i3;
  835.  /* find the filtered codeword */
  837.  for (i = 0; i < ip0; i++) y[i] = (F)0.0;
  839.  if(i0 > 0)
  840.    for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = h[j];
  841.  else
  842.    for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = -h[j];
  844.  if(i1 > 0)
  845.    for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] + h[j];
  846.  else
  847.    for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] - h[j];
  849.  if(i2 > 0)
  850.    for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] + h[j];
  851.  else
  852.    for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] - h[j];
  854.  if(i3 > 0)
  855.    for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] + h[j];
  856.  else
  857.    for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] - h[j];
  859.  /* find codebook index;  17-bit address */
  861.  i = 0;
  862.  if(i0 > 0) i += 1;
  863.  if(i1 > 0) i += 2;
  864.  if(i2 > 0) i += 4;
  865.  if(i3 > 0) i += 8;
  866.  *sign = i;
  868.  ip0 = ip0/5;
  869.  ip1 = ip1/5;
  870.  ip2 = ip2/5;
  871.  i   = ip3/5;
  872.  j   = i*5;
  873.  j   = ip3 -j -3;
  874.  ip3 = i*2+j;
  876.  i = ip0 + (ip1<<3)+ (ip2<<6)+ (ip3<<9);
  877.  return i;
  878. }