s10_8pf.cpp

实现3GPP的GSM中AMR语音的CODECS。

                alp2 = L_mac (alp1, rrv[i5], _1_4);
                alp2 = L_mac (alp2, rr[i4][i5], _1_16);

                sq2 = mult (ps2, ps2);

                alp_16 = pv_round (alp2);

                s = L_msu (L_mult (alp, sq2), sq, alp_16);

                if (s > 0)
                {
                    sq = sq2;
                    ps = ps2;
                    alp = alp_16;
                    ia = i4;
                    ib = i5;
                }
            }
        }
        i4 = ia;
        i5 = ib;

        //
        // i6 and i7 loop:
        //

        ps0 = ps;
        alp0 = L_mult (alp, _1_2);

        for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
        {
            s = L_mult (rr[i7][i7], _1_16);
            s = L_mac (s, rr[i0][i7], _1_8);
            s = L_mac (s, rr[i1][i7], _1_8);
            s = L_mac (s, rr[i2][i7], _1_8);
            s = L_mac (s, rr[i3][i7], _1_8);
            s = L_mac (s, rr[i4][i7], _1_8);
            s = L_mac (s, rr[i5][i7], _1_8);
            rrv[i7] = pv_round (s);
        }

        // Default value
        sq = -1;
        alp = 1;
        ps = 0;
        ia = ipos[6];
        ib = ipos[7];

        for (i6 = ipos[6]; i6 < L_CODE; i6 += step)
        {
            ps1 = add (ps0, dn[i6]);

            alp1 = L_mac (alp0, rr[i6][i6], _1_64);
            alp1 = L_mac (alp1, rr[i0][i6], _1_32);
            alp1 = L_mac (alp1, rr[i1][i6], _1_32);
            alp1 = L_mac (alp1, rr[i2][i6], _1_32);
            alp1 = L_mac (alp1, rr[i3][i6], _1_32);
            alp1 = L_mac (alp1, rr[i4][i6], _1_32);
            alp1 = L_mac (alp1, rr[i5][i6], _1_32);

            for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
            {
                ps2 = add (ps1, dn[i7]);

                alp2 = L_mac (alp1, rrv[i7], _1_4);
                alp2 = L_mac (alp2, rr[i6][i7], _1_32);

                sq2 = mult (ps2, ps2);

                alp_16 = pv_round (alp2);

                s = L_msu (L_mult (alp, sq2), sq, alp_16);

                if (s > 0)
                {
                    sq = sq2;
                    ps = ps2;
                    alp = alp_16;
                    ia = i6;
                    ib = i7;
                }
            }
        }
        i6 = ia;
        i7 = ib;

        // now finished searching a set of 8 pulses

        if(gsmefrFlag != 0){
           // go on with the two last pulses for GSMEFR
           //
           // i8 and i9 loop:
           //

           ps0 = ps;
           alp0 = L_mult (alp, _1_2);

           for (i9 = ipos[9]; i9 < L_CODE; i9 += step)
           {
              s = L_mult (rr[i9][i9], _1_16);
              s = L_mac (s, rr[i0][i9], _1_8);
              s = L_mac (s, rr[i1][i9], _1_8);
              s = L_mac (s, rr[i2][i9], _1_8);
              s = L_mac (s, rr[i3][i9], _1_8);
              s = L_mac (s, rr[i4][i9], _1_8);
              s = L_mac (s, rr[i5][i9], _1_8);
              s = L_mac (s, rr[i6][i9], _1_8);
              s = L_mac (s, rr[i7][i9], _1_8);
              rrv[i9] = pv_round (s);
           }

           // Default value
           sq = -1;
           alp = 1;
           ps = 0;
           ia = ipos[8];
           ib = ipos[9];

           for (i8 = ipos[8]; i8 < L_CODE; i8 += step)
           {
              ps1 = add (ps0, dn[i8]);

              alp1 = L_mac (alp0, rr[i8][i8], _1_128);
              alp1 = L_mac (alp1, rr[i0][i8], _1_64);
              alp1 = L_mac (alp1, rr[i1][i8], _1_64);
              alp1 = L_mac (alp1, rr[i2][i8], _1_64);
              alp1 = L_mac (alp1, rr[i3][i8], _1_64);
              alp1 = L_mac (alp1, rr[i4][i8], _1_64);
              alp1 = L_mac (alp1, rr[i5][i8], _1_64);
              alp1 = L_mac (alp1, rr[i6][i8], _1_64);
              alp1 = L_mac (alp1, rr[i7][i8], _1_64);

              for (i9 = ipos[9]; i9 < L_CODE; i9 += step)
              {
                 ps2 = add (ps1, dn[i9]);

                 alp2 = L_mac (alp1, rrv[i9], _1_8);
                 alp2 = L_mac (alp2, rr[i8][i9], _1_64);

                 sq2 = mult (ps2, ps2);

                 alp_16 = pv_round (alp2);

                 s = L_msu (L_mult (alp, sq2), sq, alp_16);

                 if (s > 0)
                 {
                    sq = sq2;
                    ps = ps2;
                    alp = alp_16;
                    ia = i8;
                    ib = i9;
                 }
              }
           }
        } // end  gsmefrFlag

        //
        // test and memorise if this combination is better than the last one/
        //

        s = L_msu (L_mult (alpk, sq), psk, alp);

        if (s > 0)
        {
            psk = sq;
            alpk = alp;
            codvec[0] = i0;
            codvec[1] = i1;
            codvec[2] = i2;
            codvec[3] = i3;
            codvec[4] = i4;
            codvec[5] = i5;
            codvec[6] = i6;
            codvec[7] = i7;

            if (gsmefrFlag != 0)
            {
               codvec[8] = ia;
               codvec[9] = ib;
            }
        }

        //
        // Cyclic permutation of i1,i2,i3,i4,i5,i6,i7,(i8 and i9)/
        //

        pos = ipos[1];
        for (j = 1, k = 2; k < nbPulse; j++, k++)
        {
            ipos[j] = ipos[k];
        }
        ipos[sub(nbPulse,1)] = pos;
   } // end 1..nbTracks  loop
}

------------------------------------------------------------------------------
 RESOURCES USED [optional]

 When the code is written for a specific target processor the
 the resources used should be documented below.

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

 CLOCK CYCLES: (cycle count equation for this function) + (variable
                used to represent cycle count for each subroutine
                called)
     where: (cycle count variable) = cycle count for [subroutine
                                     name]

------------------------------------------------------------------------------
 CAUTION [optional]
 [State any special notes, constraints or cautions for users of this function]

------------------------------------------------------------------------------
*/


/*----------------------------------------------------------------------------
; FUNCTION CODE
----------------------------------------------------------------------------*/
void search_10and8i40(
    Word16 nbPulse,      /* i : nbpulses to find                       */
    Word16 step,         /* i : stepsize                               */
    Word16 nbTracks,     /* i : nbTracks                               */
    Word16 dn[],         /* i : correlation between target and h[]     */
    Word16 rr[][L_CODE], /* i : matrix of autocorrelation              */
    Word16 ipos[],       /* i : starting position for each pulse       */
    Word16 pos_max[],    /* i : position of maximum of dn[]            */
    Word16 codvec[],     /* o : algebraic codebook vector              */
    Flag   *pOverflow    /* i/o : overflow flag                        */
)
{
    Word16 i0, i1, i2, i3, i4, i5, i6, i7, i9;
    Word16 i, j, k/*, m*/;
    Word16 pos, ia, ib;
    Word16 psk;
    Word16 sq, sq2;
    Word16 alpk, alp, alp_16;
    Word32 s;
    Word32 alp0, alp1, alp2;
    Word16 gsmefrFlag;
    Word16 *p_codvec = codvec;
    Word16  *p_temp2;

    Word16  temp1[2*L_CODE];
    Word16  *p_temp1;
    Word16  ps2;
    Word16  ps1;
    Word16  ps;
    Word16 ps0;

    Word16  index[10];

    OSCL_UNUSED_ARG(pOverflow);

    if (nbPulse == 10)
    {
        gsmefrFlag = 1;
    }
    else
    {
        gsmefrFlag = 0;
    }

    /* fix i0 on maximum of correlation position */
    i0 = pos_max[ipos[0]];
    index[0] = i0;
    /*------------------------------------------------------------------*
    * i1 loop:                                                         *
    *------------------------------------------------------------------*/

    /* Default value */
    psk = -1;
    alpk = 1;
    for (i = 0; i < nbPulse; i++)
    {
        *(p_codvec++) = i;
    }

    for (i = 1; i < nbTracks; i++)
    {
        i1 = pos_max[ipos[1]];
        index[1] = i1;

        /* ps0 = add (dn[i0], dn[i1], pOverflow);*/
        ps0 = (Word16)((Word32) dn[i0] + dn[i1]);

        /* alp0 = L_mult (rr[i0][i0], _1_16, pOverflow); */
        alp0 = (Word32) rr[i0][i0] << 12;

        /* alp0 = L_mac (alp0, rr[i1][i1], _1_16, pOverflow); */
        alp0 += (Word32) rr[i1][i1] << 12;

        /* alp0 = L_mac (alp0, rr[i0][i1], _1_8, pOverflow); */
        alp0 += (Word32) rr[i0][i1] << 13;
        alp0 += 0x00008000L;

        /*----------------------------------------------------------------*
        * i2 and i3 loop:                                                *
        *----------------------------------------------------------------*/

        p_temp1 = temp1;
        for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
        {
            p_temp2 = &rr[i3][0];
            s  = (Word32) * (p_temp2 + i3) >> 1;
            s += (Word32) * (p_temp2 + i0);
            s += (Word32) * (p_temp2 + i1);
            *(p_temp1++) = ps0 + dn[i3];
            *(p_temp1++) = (Word16)((s + 2) >> 2);
        }

        /* Default value */
        sq = -1;
        alp = 1;
        ps = 0;
        ia = ipos[2];
        ib = ipos[3];

        s = (alp0 >> 12);

        for (j = ipos[2]; j < L_CODE; j += step)
        {
            /* index increment = step  */
            p_temp2 = &rr[j][0];