c3_14pf.c

Trolltech公司发布的图形界面操作系统。可在qt-embedded-2.3.10平台上编译为嵌入式图形界面操作系统。

                    *----------------------------------------------------------------*/
                   
                   sq = -1;          move16 ();
                   alp = 1;          move16 ();
                   ps = 0;           move16 ();
                   ix = ipos[1];     move16 ();
                
                   /* initialize 4 index for next loop. */
                   /*-------------------------------------------------------------------*
                    *  These index have low complexity address computation because      *
                    *  they are, in fact, pointers with fixed increment.  For example,  *
                    *  "rr[i0][i2]" is a pointer initialized to "&rr[i0][ipos[2]]"      *
                    *  and incremented by "STEP".                                       *
                    *-------------------------------------------------------------------*/
                   
                   move16 (); /* account for ptr. init. (rr[i1]) */
                   move16 (); /* account for ptr. init. (dn[i1]) */
                   move16 (); /* account for ptr. init. (rr[io]) */
                   for (i1 = ipos[1]; i1 < L_CODE; i1 += STEP)
                   {
                      ps1 = add(ps0, dn[i1]);   /* idx increment = STEP */
                      
                      /* alp1 = alp0 + rr[i0][i1] + 1/2*rr[i1][i1]; */
                      
                      alp1 = L_mac(alp0, rr[i1][i1], _1_4); /* idx incr = STEP */
                      alp1 = L_mac(alp1, rr[i0][i1], _1_2); /* idx incr = STEP */
                      
                      sq1 = mult(ps1, ps1);
                      
                      alp_16 = round(alp1);
                      
                      s = L_msu(L_mult(alp, sq1), sq, alp_16);
                      
                      test ();
                      if (s > 0)
                      {
                         sq = sq1;      move16 ();
                         ps = ps1;      move16 ();
                         alp = alp_16;  move16 ();
                         ix = i1;       move16 ();
                      }
                   }
                   i1 = ix;             move16 ();
                   
                   /*----------------------------------------------------------------*
                    * i2 loop: 8 positions.                                          *
                    *----------------------------------------------------------------*/
                   
                   ps0 = ps;            move16 ();
                   alp0 = L_mult(alp, _1_4);
                   
                   sq = -1;             move16 ();
                   alp = 1;             move16 ();
                   ps = 0;              move16 ();
                   ix = ipos[2];        move16 ();
                   
                   /* initialize 4 index for next loop (see i1 loop) */
                   
                   move16 (); /* account for ptr. init. (rr[i2]) */
                   move16 (); /* account for ptr. init. (rr[i1]) */
                   move16 (); /* account for ptr. init. (dn[i2]) */
                   move16 (); /* account for ptr. init. (rr[io]) */
                   for (i2 = ipos[2]; i2 < L_CODE; i2 += STEP)
                   {
                      ps1 = add(ps0, dn[i2]); /* index increment = STEP */
                      
                      /* alp1 = alp0 + rr[i0][i2] + rr[i1][i2] + 1/2*rr[i2][i2]; */
                      
                      alp1 = L_mac(alp0, rr[i2][i2], _1_16); /* idx incr = STEP */
                      alp1 = L_mac(alp1, rr[i1][i2], _1_8);  /* idx incr = STEP */
                      alp1 = L_mac(alp1, rr[i0][i2], _1_8);  /* idx incr = STEP */
                      
                      sq1 = mult(ps1, ps1);
                      
                      alp_16 = round(alp1);
                      
                      s = L_msu(L_mult(alp, sq1), sq, alp_16);
                      
                      test ();
                      if (s > 0)
                      {
                         sq = sq1;      move16 ();
                         ps = ps1;      move16 ();
                         alp = alp_16;  move16 ();
                         ix = i2;       move16 ();
                      }
                   }
                   i2 = ix;             move16 ();
                   
                   /*----------------------------------------------------------------*
                    * memorise codevector if this one is better than the last one.   *
                    *----------------------------------------------------------------*/
                   
                   s = L_msu(L_mult(alpk, sq), psk, alp);
                   
                   test ();
                   if (s > 0)
                   {
                      psk = sq;         move16 ();
                      alpk = alp;       move16 ();
                      codvec[0] = i0;   move16 ();
                      codvec[1] = i1;   move16 ();
                      codvec[2] = i2;   move16 ();
                   }
                }
             }
             /*----------------------------------------------------------------*
              * Cyclic permutation of i0, i1 and i2.                           *
              *----------------------------------------------------------------*/
             
             pos = ipos[2];          move16 ();
             ipos[2] = ipos[1];      move16 ();
             ipos[1] = ipos[0];      move16 ();
             ipos[0] = pos;          move16 ();
          }
       }
    }    
    return;
}

/*************************************************************************
 *
 *  FUNCTION:  build_code()
 *
 *  PURPOSE: Builds the codeword, the filtered codeword and index of the
 *           codevector, based on the signs and positions of 3 pulses.
 *
 *************************************************************************/

static Word16
build_code(
    Word16 codvec[],  /* i : position of pulses                            */
    Word16 dn_sign[], /* i : sign of pulses                                */
    Word16 cod[],     /* o : innovative code vector                        */
    Word16 h[],       /* i : impulse response of weighted synthesis filter */
    Word16 y[],       /* o : filtered innovative code                      */
    Word16 sign[]     /* o : sign of 3 pulses                              */
)
{
    Word16 i, j, k, track, index, _sign[NB_PULSE], indx, rsign;
    Word16 *p0, *p1, *p2;
    Word32 s;

    for (i = 0; i < L_CODE; i++) {
       cod[i] = 0;         move16 ();
    }
    
    indx = 0;               move16 ();
    rsign = 0;              move16 ();
    for (k = 0; k < NB_PULSE; k++)
    {
       i = codvec[k];      move16 ();  /* read pulse position */
       j = dn_sign[i];     move16 ();  /* read sign           */
       
       index = mult(i, 6554);    /* index = pos/5 */
                                 /* track = pos%5 */
       track = sub(i, extract_l(L_shr(L_mult(index, 5), 1)));
       
       test ();
       if (sub(track, 1) == 0)
          index = shl(index, 4);
       else if (sub(track, 2) == 0)
       {
          test ();
          track = 2;                          move16 ();
          index = shl(index, 8);
       }
       else if (sub(track, 3) == 0)
       {
          test (); test ();
          track = 1;                          move16 ();         
          index = add(shl(index, 4), 8);
       }
       else if (sub(track, 4) == 0)
       {
          test (); test (); test ();
          track = 2;                          move16 ();
          index = add(shl(index, 8), 128);
       }
       
       test ();
       if (j > 0)
       {
          cod[i] = 8191;                       move16 ();
          _sign[k] = 32767;                    move16 ();
          rsign = add(rsign, shl(1, track));
       } else {
          cod[i] = -8192;                      move16 ();
          _sign[k] = (Word16) - 32768L;        move16 ();
       }
       
       indx = add(indx, index);
    }
    *sign = rsign;                             move16 ();

    p0 = h - codvec[0];                        move16 ();
    p1 = h - codvec[1];                        move16 ();
    p2 = h - codvec[2];                        move16 ();
    
    for (i = 0; i < L_CODE; i++)
    {
       s = 0;                                  move32 ();
       s = L_mac(s, *p0++, _sign[0]);
       s = L_mac(s, *p1++, _sign[1]);
       s = L_mac(s, *p2++, _sign[2]);
       y[i] = round(s);                        move16 ();
    }
    
    return indx;
}