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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
ACELP_CA.C
资源名称：G711-729.rar　[点击查看]
上传用户：meifeng08
上传日期：2013-06-18
资源大小：5304k
文件大小：28k
源码类别：

语音压缩

开发平台：

C/C++

ACELP_CA.C：源码内容
  1. /*
  2.    ITU-T G.729A Speech Coder    ANSI-C Source Code
  3.    Version 1.1    Last modified: September 1996
  5.    Copyright (c) 1996,
  6.    AT&T, France Telecom, NTT, Universite de Sherbrooke
  7.    All rights reserved.
  8. */
  10. /*---------------------------------------------------------------------------*
  11.  *  Function  ACELP_Code_A()                                                 *
  12.  *  ~~~~~~~~~~~~~~~~~~~~~~~~                                                 *
  13.  *   Find Algebraic codebook for G.729A                                      *
  14.  *--------------------------------------------------------------------------*/
  16. #include "typedef.h"
  17. #include "basic_op.h"
  18. #include "ld8a.h"
  20. /* Constants defined in ld8a.h */
  21. /*  L_SUBFR   -> Lenght of subframe.                                        */
  22. /*  NB_POS    -> Number of positions for each pulse.                        */
  23. /*  STEP      -> Step betweem position of the same pulse.                   */
  24. /*  MSIZE     -> Size of vectors for cross-correlation between two pulses.  */
  27. /* local routines definition */
  29. static void Cor_h(
  30.      Word16 *H,         /* (i) Q12 :Impulse response of filters */
  31.      Word16 *rr         /* (o)     :Correlations of H[]         */
  32. );
  33. static Word16 D4i40_17_fast(/*(o) : Index of pulses positions.               */
  34.   Word16 dn[],          /* (i)    : Correlations between h[] and Xn[].       */
  35.   Word16 *rr,           /* (i)    : Correlations of impulse response h[].    */
  36.   Word16 h[],           /* (i) Q12: Impulse response of filters.             */
  37.   Word16 cod[],         /* (o) Q13: Selected algebraic codeword.             */
  38.   Word16 y[],           /* (o) Q12: Filtered algebraic codeword.             */
  39.   Word16 *sign          /* (o)    : Signs of 4 pulses.                       */
  40. );
  42.  /*-----------------------------------------------------------------*
  43.   * Main ACELP function.                                            *
  44.   *-----------------------------------------------------------------*/
  46. Word16  ACELP_Code_A(    /* (o)     :index of pulses positions    */
  47.   Word16 x[],            /* (i)     :Target vector                */
  48.   Word16 h[],            /* (i) Q12 :Inpulse response of filters  */
  49.   Word16 T0,             /* (i)     :Pitch lag                    */
  50.   Word16 pitch_sharp,    /* (i) Q14 :Last quantized pitch gain    */
  51.   Word16 code[],         /* (o) Q13 :Innovative codebook          */
  52.   Word16 y[],            /* (o) Q12 :Filtered innovative codebook */
  53.   Word16 *sign           /* (o)     :Signs of 4 pulses            */
  54. )
  55. {
  56.   Word16 i, index, sharp;
  57.   Word16 Dn[L_SUBFR];
  58.   Word16 rr[DIM_RR];
  60.  /*-----------------------------------------------------------------*
  61.   * Include fixed-gain pitch contribution into impulse resp. h[]    *
  62.   * Find correlations of h[] needed for the codebook search.        *
  63.   *-----------------------------------------------------------------*/
  65.   sharp = shl(pitch_sharp, 1);          /* From Q14 to Q15 */
  66.   if (T0 < L_SUBFR)
  67.      for (i = T0; i < L_SUBFR; i++)     /* h[i] += pitch_sharp*h[i-T0] */
  68.        h[i] = add(h[i], mult(h[i-T0], sharp));
  70.   Cor_h(h, rr);
  72.  /*-----------------------------------------------------------------*
  73.   * Compute correlation of target vector with impulse response.     *
  74.   *-----------------------------------------------------------------*/
  76.   Cor_h_X(h, x, Dn);
  78.  /*-----------------------------------------------------------------*
  79.   * Find innovative codebook.                                       *
  80.   *-----------------------------------------------------------------*/
  82.   index = D4i40_17_fast(Dn, rr, h, code, y, sign);
  84.  /*-----------------------------------------------------------------*
  85.   * Compute innovation vector gain.                                 *
  86.   * Include fixed-gain pitch contribution into code[].              *
  87.   *-----------------------------------------------------------------*/
  89.   if(T0 < L_SUBFR)
  90.      for (i = T0; i < L_SUBFR; i++)    /* code[i] += pitch_sharp*code[i-T0] */
  91.        code[i] = add(code[i], mult(code[i-T0], sharp));
  93.   return index;
  94. }
  98. /*--------------------------------------------------------------------------*
  99.  *  Function  Cor_h()                                                       *
  100.  *  ~~~~~~~~~~~~~~~~~                                                       *
  101.  * Compute  correlations of h[]  needed for the codebook search.            *
  102.  *--------------------------------------------------------------------------*/
  104. static void Cor_h(
  105.   Word16 *H,     /* (i) Q12 :Impulse response of filters */
  106.   Word16 *rr     /* (o)     :Correlations of H[]         */
  107. )
  108. {
  109.   Word16 *rri0i0, *rri1i1, *rri2i2, *rri3i3, *rri4i4;
  110.   Word16 *rri0i1, *rri0i2, *rri0i3, *rri0i4;
  111.   Word16 *rri1i2, *rri1i3, *rri1i4;
  112.   Word16 *rri2i3, *rri2i4;
  114.   Word16 *p0, *p1, *p2, *p3, *p4;
  116.   Word16 *ptr_hd, *ptr_hf, *ptr_h1, *ptr_h2;
  117.   Word32 cor;
  118.   Word16 i, k, ldec, l_fin_sup, l_fin_inf;
  119.   Word16 h[L_SUBFR];
  121.  /* Scaling h[] for maximum precision */
  123.   cor = 0;
  124.   for(i=0; i<L_SUBFR; i++)
  125.     cor = L_mac(cor, H[i], H[i]);
  127.   if(sub(extract_h(cor),32000) > 0)
  128.   {
  129.     for(i=0; i<L_SUBFR; i++) {
  130.       h[i] = shr(H[i], 1);
  131.     }
  132.   }
  133.   else
  134.   {
  135.     k = norm_l(cor);
  136.     k = shr(k, 1);
  138.     for(i=0; i<L_SUBFR; i++) {
  139.       h[i] = shl(H[i], k);
  140.     }
  141.   }
  144.  /*------------------------------------------------------------*
  145.   * Compute rri0i0[], rri1i1[], rri2i2[], rri3i3 and rri4i4[]  *
  146.   *------------------------------------------------------------*/
  147.   /* Init pointers */
  148.   rri0i0 = rr;
  149.   rri1i1 = rri0i0 + NB_POS;
  150.   rri2i2 = rri1i1 + NB_POS;
  151.   rri3i3 = rri2i2 + NB_POS;
  152.   rri4i4 = rri3i3 + NB_POS;
  153.   rri0i1 = rri4i4 + NB_POS;
  154.   rri0i2 = rri0i1 + MSIZE;
  155.   rri0i3 = rri0i2 + MSIZE;
  156.   rri0i4 = rri0i3 + MSIZE;
  157.   rri1i2 = rri0i4 + MSIZE;
  158.   rri1i3 = rri1i2 + MSIZE;
  159.   rri1i4 = rri1i3 + MSIZE;
  160.   rri2i3 = rri1i4 + MSIZE;
  161.   rri2i4 = rri2i3 + MSIZE;
  163.   p0 = rri0i0 + NB_POS-1;   /* Init pointers to last position of rrixix[] */
  164.   p1 = rri1i1 + NB_POS-1;
  165.   p2 = rri2i2 + NB_POS-1;
  166.   p3 = rri3i3 + NB_POS-1;
  167.   p4 = rri4i4 + NB_POS-1;
  169.   ptr_h1 = h;
  170.   cor    = 0;
  171.   for(i=0;  i<NB_POS; i++)
  172.   {
  173.     cor = L_mac(cor, *ptr_h1, *ptr_h1); ptr_h1++;
  174.     *p4-- = extract_h(cor);
  176.     cor = L_mac(cor, *ptr_h1, *ptr_h1); ptr_h1++;
  177.     *p3-- = extract_h(cor);
  179.     cor = L_mac(cor, *ptr_h1, *ptr_h1); ptr_h1++;
  180.     *p2-- = extract_h(cor);
  182.     cor = L_mac(cor, *ptr_h1, *ptr_h1); ptr_h1++;
  183.     *p1-- = extract_h(cor);
  185.     cor = L_mac(cor, *ptr_h1, *ptr_h1); ptr_h1++;
  186.     *p0-- = extract_h(cor);
  187.   }
  189.  /*-----------------------------------------------------------------*
  190.   * Compute elements of: rri2i3[], rri1i2[], rri0i1[] and rri0i4[]  *
  191.   *-----------------------------------------------------------------*/
  193.   l_fin_sup = MSIZE-1;
  194.   l_fin_inf = l_fin_sup-(Word16)1;
  195.   ldec = NB_POS+1;
  197.   ptr_hd = h;
  198.   ptr_hf = ptr_hd + 1;
  200.   for(k=0; k<NB_POS; k++) {
  202.           p3 = rri2i3 + l_fin_sup;
  203.           p2 = rri1i2 + l_fin_sup;
  204.           p1 = rri0i1 + l_fin_sup;
  205.           p0 = rri0i4 + l_fin_inf;
  207.           cor = 0;
  208.           ptr_h1 = ptr_hd;
  209.           ptr_h2 =  ptr_hf;
  211.           for(i=k+(Word16)1; i<NB_POS; i++ ) {
  213.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  214.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  215.                   *p3 = extract_h(cor);
  217.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  218.                   *p2 = extract_h(cor);
  220.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  221.                   *p1 = extract_h(cor);
  223.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  224.                   *p0 = extract_h(cor);
  226.                   p3 -= ldec;
  227.                   p2 -= ldec;
  228.                   p1 -= ldec;
  229.                   p0 -= ldec;
  230.           }
  231.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  232.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  233.           *p3 = extract_h(cor);
  235.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  236.           *p2 = extract_h(cor);
  238.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  239.           *p1 = extract_h(cor);
  241.           l_fin_sup -= NB_POS;
  242.           l_fin_inf--;
  243.           ptr_hf += STEP;
  244.   }
  246.  /*---------------------------------------------------------------------*
  247.   * Compute elements of: rri2i4[], rri1i3[], rri0i2[], rri1i4[], rri0i3 *
  248.   *---------------------------------------------------------------------*/
  250.   ptr_hd = h;
  251.   ptr_hf = ptr_hd + 2;
  252.   l_fin_sup = MSIZE-1;
  253.   l_fin_inf = l_fin_sup-(Word16)1;
  254.   for(k=0; k<NB_POS; k++) {
  256.           p4 = rri2i4 + l_fin_sup;
  257.           p3 = rri1i3 + l_fin_sup;
  258.           p2 = rri0i2 + l_fin_sup;
  259.           p1 = rri1i4 + l_fin_inf;
  260.           p0 = rri0i3 + l_fin_inf;
  262.           cor = 0;
  263.           ptr_h1 = ptr_hd;
  264.           ptr_h2 =  ptr_hf;
  265.           for(i=k+(Word16)1; i<NB_POS; i++ ) {
  267.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  268.                   *p4 = extract_h(cor);
  270.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  271.                   *p3 = extract_h(cor);
  273.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  274.                   *p2 = extract_h(cor);
  276.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  277.                   *p1 = extract_h(cor);
  279.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  280.                   *p0 = extract_h(cor);
  282.                   p4 -= ldec;
  283.                   p3 -= ldec;
  284.                   p2 -= ldec;
  285.                   p1 -= ldec;
  286.                   p0 -= ldec;
  287.           }
  288.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  289.           *p4 = extract_h(cor);
  291.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  292.           *p3 = extract_h(cor);
  294.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  295.           *p2 = extract_h(cor);
  298.           l_fin_sup -= NB_POS;
  299.           l_fin_inf--;
  300.           ptr_hf += STEP;
  301.   }
  303.  /*----------------------------------------------------------------------*
  304.   * Compute elements of: rri1i4[], rri0i3[], rri2i4[], rri1i3[], rri0i2  *
  305.   *----------------------------------------------------------------------*/
  307.   ptr_hd = h;
  308.   ptr_hf = ptr_hd + 3;
  309.   l_fin_sup = MSIZE-1;
  310.   l_fin_inf = l_fin_sup-(Word16)1;
  311.   for(k=0; k<NB_POS; k++) {
  313.           p4 = rri1i4 + l_fin_sup;
  314.           p3 = rri0i3 + l_fin_sup;
  315.           p2 = rri2i4 + l_fin_inf;
  316.           p1 = rri1i3 + l_fin_inf;
  317.           p0 = rri0i2 + l_fin_inf;
  319.           ptr_h1 = ptr_hd;
  320.           ptr_h2 =  ptr_hf;
  321.           cor = 0;
  322.           for(i=k+(Word16)1; i<NB_POS; i++ ) {
  324.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  325.                   *p4 = extract_h(cor);
  327.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  328.                   *p3 = extract_h(cor);
  330.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  331.                   *p2 = extract_h(cor);
  333.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  334.                   *p1 = extract_h(cor);
  336.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  337.                   *p0 = extract_h(cor);
  339.                   p4 -= ldec;
  340.                   p3 -= ldec;
  341.                   p2 -= ldec;
  342.                   p1 -= ldec;
  343.                   p0 -= ldec;
  344.           }
  345.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  346.           *p4 = extract_h(cor);
  348.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  349.           *p3 = extract_h(cor);
  351.           l_fin_sup -= NB_POS;
  352.           l_fin_inf--;
  353.           ptr_hf += STEP;
  354.   }
  356.  /*----------------------------------------------------------------------*
  357.   * Compute elements of: rri0i4[], rri2i3[], rri1i2[], rri0i1[]          *
  358.   *----------------------------------------------------------------------*/
  360.   ptr_hd = h;
  361.   ptr_hf = ptr_hd + 4;
  362.   l_fin_sup = MSIZE-1;
  363.   l_fin_inf = l_fin_sup-(Word16)1;
  364.   for(k=0; k<NB_POS; k++) {
  366.           p3 = rri0i4 + l_fin_sup;
  367.           p2 = rri2i3 + l_fin_inf;
  368.           p1 = rri1i2 + l_fin_inf;
  369.           p0 = rri0i1 + l_fin_inf;
  371.           ptr_h1 = ptr_hd;
  372.           ptr_h2 =  ptr_hf;
  373.           cor = 0;
  374.           for(i=k+(Word16)1; i<NB_POS; i++ ) {
  376.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  377.                   *p3 = extract_h(cor);
  379.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  380.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  381.                   *p2 = extract_h(cor);
  383.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  384.                   *p1 = extract_h(cor);
  386.                   cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  387.                   *p0 = extract_h(cor);
  389.                   p3 -= ldec;
  390.                   p2 -= ldec;
  391.                   p1 -= ldec;
  392.                   p0 -= ldec;
  393.           }
  394.           cor = L_mac(cor, *ptr_h1, *ptr_h2); ptr_h1++; ptr_h2++;
  395.           *p3 = extract_h(cor);
  397.           l_fin_sup -= NB_POS;
  398.           l_fin_inf--;
  399.           ptr_hf += STEP;
  400.   }
  401.   return;
  402. }
  406. /*------------------------------------------------------------------------*
  407.  * Function  D4i40_17_fast()                                              *
  408.  *           ~~~~~~~~~                                                    *
  409.  * Algebraic codebook for ITU 8kb/s.                                      *
  410.  *  -> 17 bits; 4 pulses in a frame of 40 samples                         *
  411.  *                                                                        *
  412.  *------------------------------------------------------------------------*
  413.  * The code length is 40, containing 4 nonzero pulses i0, i1, i2, i3.     *
  414.  * Each pulses can have 8 possible positions (positive or negative)       *
  415.  * except i3 that have 16 possible positions.                             *
  416.  *                                                                        *
  417.  * i0 (+-1) : 0, 5, 10, 15, 20, 25, 30, 35                                *
  418.  * i1 (+-1) : 1, 6, 11, 16, 21, 26, 31, 36                                *
  419.  * i2 (+-1) : 2, 7, 12, 17, 22, 27, 32, 37                                *
  420.  * i3 (+-1) : 3, 8, 13, 18, 23, 28, 33, 38                                *
  421.  *            4, 9, 14, 19, 24, 29, 34, 39                                *
  422.  *------------------------------------------------------------------------*/
  424. static Word16 D4i40_17_fast(/*(o) : Index of pulses positions.               */
  425.   Word16 dn[],          /* (i)    : Correlations between h[] and Xn[].       */
  426.   Word16 rr[],          /* (i)    : Correlations of impulse response h[].    */
  427.   Word16 h[],           /* (i) Q12: Impulse response of filters.             */
  428.   Word16 cod[],         /* (o) Q13: Selected algebraic codeword.             */
  429.   Word16 y[],           /* (o) Q12: Filtered algebraic codeword.             */
  430.   Word16 *sign          /* (o)    : Signs of 4 pulses.                       */
  431. )
  432. {
  433.   Word16 i0, i1, i2, i3, ip0, ip1, ip2, ip3;
  434.   Word16 i, j, ix, iy, track, trk, max;
  435.   Word16 prev_i0, i1_offset;
  436.   Word16 psk, ps, ps0, ps1, ps2, sq, sq2;
  437.   Word16 alpk, alp, alp_16;
  438.   Word32 s, alp0, alp1, alp2;
  439.   Word16 *p0, *p1, *p2, *p3, *p4;
  440.   Word16 sign_dn[L_SUBFR], sign_dn_inv[L_SUBFR], *psign;
  441.   Word16 tmp_vect[NB_POS];
  442.   Word16 *rri0i0, *rri1i1, *rri2i2, *rri3i3, *rri4i4;
  443.   Word16 *rri0i1, *rri0i2, *rri0i3, *rri0i4;
  444.   Word16 *rri1i2, *rri1i3, *rri1i4;
  445.   Word16 *rri2i3, *rri2i4;
  447.   Word16  *ptr_rri0i3_i4;
  448.   Word16  *ptr_rri1i3_i4;
  449.   Word16  *ptr_rri2i3_i4;
  450.   Word16  *ptr_rri3i3_i4;
  452.      /* Init pointers */
  453.    rri0i0 = rr;
  454.    rri1i1 = rri0i0 + NB_POS;
  455.    rri2i2 = rri1i1 + NB_POS;
  456.    rri3i3 = rri2i2 + NB_POS;
  457.    rri4i4 = rri3i3 + NB_POS;
  458.    rri0i1 = rri4i4 + NB_POS;
  459.    rri0i2 = rri0i1 + MSIZE;
  460.    rri0i3 = rri0i2 + MSIZE;
  461.    rri0i4 = rri0i3 + MSIZE;
  462.    rri1i2 = rri0i4 + MSIZE;
  463.    rri1i3 = rri1i2 + MSIZE;
  464.    rri1i4 = rri1i3 + MSIZE;
  465.    rri2i3 = rri1i4 + MSIZE;
  466.    rri2i4 = rri2i3 + MSIZE;
  468.  /*-----------------------------------------------------------------------*
  469.   * Chose the sign of the impulse.                                        *
  470.   *-----------------------------------------------------------------------*/
  472.    for (i=0; i<L_SUBFR; i++)
  473.    {
  474.      if (dn[i] >= 0)
  475.      {
  476.        sign_dn[i] = MAX_16;
  477.        sign_dn_inv[i] = MIN_16;
  478.      }
  479.      else
  480.      {
  481.        sign_dn[i] = MIN_16;
  482.        sign_dn_inv[i] = MAX_16;
  483.        dn[i] = negate(dn[i]);
  484.      }
  485.    }
  487.  /*-------------------------------------------------------------------*
  488.   * Modification of rrixiy[] to take signs into account.              *
  489.   *-------------------------------------------------------------------*/
  491.   p0 = rri0i1;
  492.   p1 = rri0i2;
  493.   p2 = rri0i3;
  494.   p3 = rri0i4;
  496.   for(i0=0; i0<L_SUBFR; i0+=STEP)
  497.   {
  498.     psign = sign_dn;
  499.     if (psign[i0] < 0) psign = sign_dn_inv;
  501.     for(i1=1; i1<L_SUBFR; i1+=STEP)
  502.     {
  503.       *p0++ = mult(*p0, psign[i1]);
  504.       *p1++ = mult(*p1, psign[i1+1]);
  505.       *p2++ = mult(*p2, psign[i1+2]);
  506.       *p3++ = mult(*p3, psign[i1+3]);
  507.     }
  508.   }
  510.   p0 = rri1i2;
  511.   p1 = rri1i3;
  512.   p2 = rri1i4;
  514.   for(i1=1; i1<L_SUBFR; i1+=STEP)
  515.   {
  516.     psign = sign_dn;
  517.     if (psign[i1] < 0) psign = sign_dn_inv;
  519.     for(i2=2; i2<L_SUBFR; i2+=STEP)
  520.     {
  521.       *p0++ = mult(*p0, psign[i2]);
  522.       *p1++ = mult(*p1, psign[i2+1]);
  523.       *p2++ = mult(*p2, psign[i2+2]);
  524.     }
  525.   }
  527.   p0 = rri2i3;
  528.   p1 = rri2i4;
  530.   for(i2=2; i2<L_SUBFR; i2+=STEP)
  531.   {
  532.     psign = sign_dn;
  533.     if (psign[i2] < 0) psign = sign_dn_inv;
  535.     for(i3=3; i3<L_SUBFR; i3+=STEP)
  536.     {
  537.       *p0++ = mult(*p0, psign[i3]);
  538.       *p1++ = mult(*p1, psign[i3+1]);
  539.     }
  540.   }
  543.  /*-------------------------------------------------------------------*
  544.   * Search the optimum positions of the four pulses which maximize    *
  545.   *     square(correlation) / energy                                  *
  546.   *-------------------------------------------------------------------*/
  548.   psk = -1;
  549.   alpk = 1;
  551.   ptr_rri0i3_i4 = rri0i3;
  552.   ptr_rri1i3_i4 = rri1i3;
  553.   ptr_rri2i3_i4 = rri2i3;
  554.   ptr_rri3i3_i4 = rri3i3;
  556.   /* Initializations only to remove warning from some compilers */
  558.   ip0=0; ip1=1; ip2=2; ip3=3; ix=0; iy=0; ps=0;
  560.   /* search 2 times: track 3 and 4 */
  561.   for (track=3, trk=0; track<5; track++, trk++)
  562.   {
  563.    /*------------------------------------------------------------------*
  564.     * depth first search 3, phase A: track 2 and 3/4.                  *
  565.     *------------------------------------------------------------------*/
  567.     sq = -1;
  568.     alp = 1;
  570.     /* i0 loop: 2 positions in track 2 */
  572.     prev_i0  = -1;
  574.     for (i=0; i<2; i++)
  575.     {
  576.       max = -1;
  577.       /* search "dn[]" maximum position in track 2 */
  578.       for (j=2; j<L_SUBFR; j+=STEP)
  579.       {
  580.         if ((sub(dn[j], max) > 0) && (sub(prev_i0,j) != 0))
  581.         {
  582.           max = dn[j];
  583.           i0 = j;
  584.         }
  585.       }
  586.       prev_i0 = i0;
  588.       j = mult(i0, 6554);        /* j = i0/5 */
  589.       p0 = rri2i2 + j;
  591.       ps1 = dn[i0];
  592.       alp1 = L_mult(*p0, _1_4);
  594.       /* i1 loop: 8 positions in track 2 */
  596.       p0 = ptr_rri2i3_i4 + shl(j, 3);
  597.       p1 = ptr_rri3i3_i4;
  599.       for (i1=track; i1<L_SUBFR; i1+=STEP)
  600.       {
  601.         ps2 = add(ps1, dn[i1]);       /* index increment = STEP */
  603.         /* alp1 = alp0 + rr[i0][i1] + 1/2*rr[i1][i1]; */
  604.         alp2 = L_mac(alp1, *p0++, _1_2);
  605.         alp2 = L_mac(alp2, *p1++, _1_4);
  607.         sq2 = mult(ps2, ps2);
  608.         alp_16 = round(alp2);
  610.         s = L_msu(L_mult(alp,sq2),sq,alp_16);
  611.         if (s > 0)
  612.         {
  613.           sq = sq2;
  614.           ps = ps2;
  615.           alp = alp_16;
  616.           ix = i0;
  617.           iy = i1;
  618.         }
  619.       }
  620.     }
  622.     i0 = ix;
  623.     i1 = iy;
  624.     i1_offset = shl(mult(i1, 6554), 3);       /* j = 8*(i1/5) */
  626.    /*------------------------------------------------------------------*
  627.     * depth first search 3, phase B: track 0 and 1.                    *
  628.     *------------------------------------------------------------------*/
  630.     ps0 = ps;
  631.     alp0 = L_mult(alp, _1_4);
  633.     sq = -1;
  634.     alp = 1;
  636.     /* build vector for next loop to decrease complexity */
  638.     p0 = rri1i2 + mult(i0, 6554);
  639.     p1 = ptr_rri1i3_i4 + mult(i1, 6554);
  640.     p2 = rri1i1;
  641.     p3 = tmp_vect;
  643.     for (i3=1; i3<L_SUBFR; i3+=STEP)
  644.     {
  645.       /* rrv[i3] = rr[i3][i3] + rr[i0][i3] + rr[i1][i3]; */
  646.       s = L_mult(*p0, _1_4);        p0 += NB_POS;
  647.       s = L_mac(s, *p1, _1_4);      p1 += NB_POS;
  648.       s = L_mac(s, *p2++, _1_8);
  649.       *p3++ = round(s);
  650.     }
  652.     /* i2 loop: 8 positions in track 0 */
  654.     p0 = rri0i2 + mult(i0, 6554);
  655.     p1 = ptr_rri0i3_i4 + mult(i1, 6554);
  656.     p2 = rri0i0;
  657.     p3 = rri0i1;
  659.     for (i2=0; i2<L_SUBFR; i2+=STEP)
  660.     {
  661.       ps1 = add(ps0, dn[i2]);         /* index increment = STEP */
  663.       /* alp1 = alp0 + rr[i0][i2] + rr[i1][i2] + 1/2*rr[i2][i2]; */
  664.       alp1 = L_mac(alp0, *p0, _1_8);       p0 += NB_POS;
  665.       alp1 = L_mac(alp1, *p1, _1_8);       p1 += NB_POS;
  666.       alp1 = L_mac(alp1, *p2++, _1_16);
  668.       /* i3 loop: 8 positions in track 1 */
  670.       p4 = tmp_vect;
  672.       for (i3=1; i3<L_SUBFR; i3+=STEP)
  673.       {
  674.         ps2 = add(ps1, dn[i3]);       /* index increment = STEP */
  676.         /* alp1 = alp0 + rr[i0][i3] + rr[i1][i3] + rr[i2][i3] + 1/2*rr[i3][i3]; */
  677.         alp2 = L_mac(alp1, *p3++, _1_8);
  678.         alp2 = L_mac(alp2, *p4++, _1_2);
  680.         sq2 = mult(ps2, ps2);
  681.         alp_16 = round(alp2);
  683.         s = L_msu(L_mult(alp,sq2),sq,alp_16);
  684.         if (s > 0)
  685.         {
  686.           sq = sq2;
  687.           alp = alp_16;
  688.           ix = i2;
  689.           iy = i3;
  690.         }
  691.       }
  692.     }
  694.    /*----------------------------------------------------------------*
  695.     * depth first search 3: compare codevector with the best case.   *
  696.     *----------------------------------------------------------------*/
  698.     s = L_msu(L_mult(alpk,sq),psk,alp);
  699.     if (s > 0)
  700.     {
  701.       psk = sq;
  702.       alpk = alp;
  703.       ip2 = i0;
  704.       ip3 = i1;
  705.       ip0 = ix;
  706.       ip1 = iy;
  707.     }
  709.    /*------------------------------------------------------------------*
  710.     * depth first search 4, phase A: track 3 and 0.                    *
  711.     *------------------------------------------------------------------*/
  713.     sq = -1;
  714.     alp = 1;
  716.     /* i0 loop: 2 positions in track 3/4 */
  718.     prev_i0  = -1;
  720.     for (i=0; i<2; i++)
  721.     {
  722.       max = -1;
  723.       /* search "dn[]" maximum position in track 3/4 */
  724.       for (j=track; j<L_SUBFR; j+=STEP)
  725.       {
  726.         if ((sub(dn[j], max) > 0) && (sub(prev_i0,j) != 0))
  727.         {
  728.           max = dn[j];
  729.           i0 = j;
  730.         }
  731.       }
  732.       prev_i0 = i0;
  734.       j = mult(i0, 6554);        /* j = i0/5 */
  735.       p0 = ptr_rri3i3_i4 + j;
  737.       ps1 = dn[i0];
  738.       alp1 = L_mult(*p0, _1_4);
  740.       /* i1 loop: 8 positions in track 0 */
  742.       p0 = ptr_rri0i3_i4 + j;
  743.       p1 = rri0i0;
  745.       for (i1=0; i1<L_SUBFR; i1+=STEP)
  746.       {
  747.         ps2 = add(ps1, dn[i1]);       /* index increment = STEP */
  749.         /* alp1 = alp0 + rr[i0][i1] + 1/2*rr[i1][i1]; */
  750.         alp2 = L_mac(alp1, *p0, _1_2);       p0 += NB_POS;
  751.         alp2 = L_mac(alp2, *p1++, _1_4);
  753.         sq2 = mult(ps2, ps2);
  754.         alp_16 = round(alp2);
  756.         s = L_msu(L_mult(alp,sq2),sq,alp_16);
  757.         if (s > 0)
  758.         {
  759.           sq = sq2;
  760.           ps = ps2;
  761.           alp = alp_16;
  762.           ix = i0;
  763.           iy = i1;
  764.         }
  765.       }
  766.     }
  768.     i0 = ix;
  769.     i1 = iy;
  770.     i1_offset = shl(mult(i1, 6554), 3);       /* j = 8*(i1/5) */
  772.    /*------------------------------------------------------------------*
  773.     * depth first search 4, phase B: track 1 and 2.                    *
  774.     *------------------------------------------------------------------*/
  776.     ps0 = ps;
  777.     alp0 = L_mult(alp, _1_4);
  779.     sq = -1;
  780.     alp = 1;
  782.     /* build vector for next loop to decrease complexity */
  784.     p0 = ptr_rri2i3_i4 + mult(i0, 6554);
  785.     p1 = rri0i2 + i1_offset;
  786.     p2 = rri2i2;
  787.     p3 = tmp_vect;
  789.     for (i3=2; i3<L_SUBFR; i3+=STEP)
  790.     {
  791.       /* rrv[i3] = rr[i3][i3] + rr[i0][i3] + rr[i1][i3]; */
  792.       s = L_mult(*p0, _1_4);         p0 += NB_POS;
  793.       s = L_mac(s, *p1++, _1_4);
  794.       s = L_mac(s, *p2++, _1_8);
  795.       *p3++ = round(s);
  796.     }
  798.     /* i2 loop: 8 positions in track 1 */
  800.     p0 = ptr_rri1i3_i4 + mult(i0, 6554);
  801.     p1 = rri0i1 + i1_offset;
  802.     p2 = rri1i1;
  803.     p3 = rri1i2;
  805.     for (i2=1; i2<L_SUBFR; i2+=STEP)
  806.     {
  807.       ps1 = add(ps0, dn[i2]);         /* index increment = STEP */
  809.       /* alp1 = alp0 + rr[i0][i2] + rr[i1][i2] + 1/2*rr[i2][i2]; */
  810.       alp1 = L_mac(alp0, *p0, _1_8);       p0 += NB_POS;
  811.       alp1 = L_mac(alp1, *p1++, _1_8);
  812.       alp1 = L_mac(alp1, *p2++, _1_16);
  814.       /* i3 loop: 8 positions in track 2 */
  816.       p4 = tmp_vect;
  818.       for (i3=2; i3<L_SUBFR; i3+=STEP)
  819.       {
  820.         ps2 = add(ps1, dn[i3]);       /* index increment = STEP */
  822.         /* alp1 = alp0 + rr[i0][i3] + rr[i1][i3] + rr[i2][i3] + 1/2*rr[i3][i3]; */
  823.         alp2 = L_mac(alp1, *p3++, _1_8);
  824.         alp2 = L_mac(alp2, *p4++, _1_2);
  826.         sq2 = mult(ps2, ps2);
  827.         alp_16 = round(alp2);
  829.         s = L_msu(L_mult(alp,sq2),sq,alp_16);
  830.         if (s > 0)
  831.         {
  832.           sq = sq2;
  833.           alp = alp_16;
  834.           ix = i2;
  835.           iy = i3;
  836.         }
  837.       }
  838.     }
  840.    /*----------------------------------------------------------------*
  841.     * depth first search 1: compare codevector with the best case.   *
  842.     *----------------------------------------------------------------*/
  844.     s = L_msu(L_mult(alpk,sq),psk,alp);
  845.     if (s > 0)
  846.     {
  847.       psk = sq;
  848.       alpk = alp;
  849.       ip3 = i0;
  850.       ip0 = i1;
  851.       ip1 = ix;
  852.       ip2 = iy;
  853.     }
  855.   ptr_rri0i3_i4 = rri0i4;
  856.   ptr_rri1i3_i4 = rri1i4;
  857.   ptr_rri2i3_i4 = rri2i4;
  858.   ptr_rri3i3_i4 = rri4i4;
  860.   }
  863.  /* Set the sign of impulses */
  865.  i0 = sign_dn[ip0];
  866.  i1 = sign_dn[ip1];
  867.  i2 = sign_dn[ip2];
  868.  i3 = sign_dn[ip3];
  870.  /* Find the codeword corresponding to the selected positions */
  873.  for(i=0; i<L_SUBFR; i++) {
  874.    cod[i] = 0;
  875.  }
  877.  cod[ip0] = shr(i0, 2);         /* From Q15 to Q13 */
  878.  cod[ip1] = shr(i1, 2);
  879.  cod[ip2] = shr(i2, 2);
  880.  cod[ip3] = shr(i3, 2);
  882.  /* find the filtered codeword */
  884.  for (i = 0; i < ip0; i++) y[i] = 0;
  886.  if(i0 > 0)
  887.    for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = h[j];
  888.  else
  889.    for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = negate(h[j]);
  891.  if(i1 > 0)
  892.    for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = add(y[i], h[j]);
  893.  else
  894.    for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = sub(y[i], h[j]);
  896.  if(i2 > 0)
  897.    for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = add(y[i], h[j]);
  898.  else
  899.    for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = sub(y[i], h[j]);
  901.  if(i3 > 0)
  902.    for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = add(y[i], h[j]);
  903.  else
  904.    for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = sub(y[i], h[j]);
  906.  /* find codebook index;  17-bit address */
  908.  i = 0;
  909.  if(i0 > 0) i = add(i, 1);
  910.  if(i1 > 0) i = add(i, 2);
  911.  if(i2 > 0) i = add(i, 4);
  912.  if(i3 > 0) i = add(i, 8);
  913.  *sign = i;
  915.  ip0 = mult(ip0, 6554);         /* ip0/5 */
  916.  ip1 = mult(ip1, 6554);         /* ip1/5 */
  917.  ip2 = mult(ip2, 6554);         /* ip2/5 */
  918.  i   = mult(ip3, 6554);         /* ip3/5 */
  919.  j   = add(i, shl(i, 2));       /* j = i*5 */
  920.  j   = sub(ip3, add(j, 3));     /* j= ip3%5 -3 */
  921.  ip3 = add(shl(i, 1), j);
  923.  i = add(ip0, shl(ip1, 3));
  924.  i = add(i  , shl(ip2, 6));
  925.  i = add(i  , shl(ip3, 9));
  927.  return i;
  928. }