s10_8pf.cpp

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

            alp1 = (s + (Word32) * (p_temp2 + j)) >> 1;

            alp1 += (Word32) * (p_temp2 + i0);

            alp1 += (Word32) * (p_temp2 + i1);

            p_temp1 = temp1;
            ps1 = dn[j];


            for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
            {
                /* index increment = step */
                ps2 = ps1 + *(p_temp1++);

                sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);

                alp2 = (alp1 + p_temp2[i3]) >> 2;
                alp2 = (alp2 + *(p_temp1++)) >> 1;  /*  alp2 is always > 0  */
                if (((Word32) sq2 * alp) > ((Word32) sq * alp2))
                {
                    sq = sq2;
                    ps = ps2;
                    alp = (Word16)alp2;
                    ia = j;
                    ib = i3;
                }
            }

        }
        i2 = ia;
        i3 = ib;
        index[2] = ia;
        index[3] = ib;

        /*----------------------------------------------------------------*
        * i4 and i5 loop:                                                *
        *----------------------------------------------------------------*/

        alp0 = ((Word32) alp << 15) + 0x00008000L;
        p_temp1 = temp1;

        for (i5 = ipos[5]; i5 < L_CODE; i5 += step)
        {
            p_temp2 = &rr[i5][0];
            s = (Word32) * (p_temp2 + i5) >> 1;
            s += (Word32) * (p_temp2 + i0);
            s += (Word32) * (p_temp2 + i1);
            s += (Word32) * (p_temp2 + i2);
            s += (Word32) * (p_temp2 + i3);

            *(p_temp1++) = ps + dn[i5];
            *(p_temp1++) = (Word16)((s + 2) >> 2);
        }

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

        for (j = ipos[4]; j < L_CODE; j += step)
        {
            /* ps1 = add (ps0, dn[i4], pOverflow); */
            p_temp2 = &rr[j][0];

            /* alp1 = L_mac (alp0, rr[i4][i4], _1_32, pOverflow); */
            alp1 = alp0 + ((Word32) * (p_temp2 + j) << 11);

            /* alp1 = L_mac (alp1, rr[i0][i4], _1_16, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i0) << 12;

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

            /* alp1 = L_mac (alp1, rr[i2][i4], _1_16, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i2) << 12;

            /* alp1 = L_mac (alp1, rr[i3][i4], _1_16, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i3) << 12;

            p_temp1 = temp1;
            ps1 =  dn[j];

            for (i5 = ipos[5]; i5 < L_CODE; i5 += step)
            {
                ps2 = ps1 + *(p_temp1++);

                alp2 = alp1 + ((Word32) * (p_temp2 + i5) << 12);

                alp_16 = (Word16)((alp2 + ((Word32) * (p_temp1++) << 14)) >> 16);
                sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);

                if (((Word32) sq2 * alp) > ((Word32) sq * alp_16))
                {
                    sq = sq2;
                    ps = ps2;
                    alp = alp_16;
                    ia = j;
                    ib = i5;
                }

            }
        }
        i4 = ia;
        i5 = ib;
        index[4] = ia;
        index[5] = ib;

        /*----------------------------------------------------------------*
        * i6 and i7 loop:                                                *
        *----------------------------------------------------------------*/

        alp0 = ((Word32) alp << 15) + 0x00008000L;

        p_temp1 = temp1;

        for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
        {
            s = (Word32) rr[i7][i7] >> 1;
            s += (Word32) rr[i0][i7];
            s += (Word32) rr[i1][i7];
            s += (Word32) rr[i2][i7];
            s += (Word32) rr[i3][i7];
            s += (Word32) rr[i4][i7];
            s += (Word32) rr[i5][i7];
            *(p_temp1++) = ps + dn[i7];
            *(p_temp1++) = (Word16)((s + 4) >> 3);
        }


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

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

            p_temp2 = (Word16 *) & rr[j];

            /* alp1 = L_mac (alp0, rr[i6][i6], _1_64, pOverflow); */
            alp1 = alp0 + ((Word32) * (p_temp2 + j) << 10);

            /* alp1 = L_mac (alp1, rr[i0][i6], _1_32, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i0) << 11;


            /* alp1 = L_mac (alp1, rr[i1][i6], _1_32, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i1) << 11;

            /* alp1 = L_mac (alp1, rr[i2][i6], _1_32, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i2) << 11;

            /* alp1 = L_mac (alp1, rr[i3][i6], _1_32, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i3) << 11;

            /* alp1 = L_mac (alp1, rr[i4][i6], _1_32, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i4) << 11;

            /* alp1 = L_mac (alp1, rr[i5][i6], _1_32, pOverflow); */
            alp1 += (Word32) * (p_temp2 + i5) << 11;

            p_temp1 = temp1;
            ps1 = dn[j];

            for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
            {
                ps2 = ps1 + *(p_temp1++);

                alp2 = alp1 + ((Word32) * (p_temp2 + i7) << 11);

                alp_16 = (Word16)((alp2 + ((Word32) * (p_temp1++) << 14)) >> 16);

                sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);

                if (((Word32) sq2 * alp) > ((Word32) sq * alp_16))
                {
                    sq = sq2;
                    ps = ps2;
                    alp = alp_16;
                    ia = j;
                    ib = i7;
                }
            }
        }

        i6 = ia;
        i7 = ib;
        index[6] = ia;
        index[7] = 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:                                                *
            *----------------------------------------------------------------*/

            alp0 = ((Word32) alp << 15) + 0x00008000L;

            p_temp1 = temp1;

            for (i9 = ipos[9]; i9 < L_CODE; i9 += step)
            {
                s = (Word32) rr[i9][i9] >> 1;
                s += (Word32) rr[i0][i9];
                s += (Word32) rr[i1][i9];
                s += (Word32) rr[i2][i9];
                s += (Word32) rr[i3][i9];
                s += (Word32) rr[i4][i9];
                s += (Word32) rr[i5][i9];
                s += (Word32) rr[i6][i9];
                s += (Word32) rr[i7][i9];

                *(p_temp1++) = ps + dn[i9];
                *(p_temp1++) = (Word16)((s + 4) >> 3);
            }

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

            for (j = ipos[8]; j < L_CODE; j += step)
            {
                /* ps1 = add (ps0, dn[i8], pOverflow); */
                p_temp2 = &rr[j][0];

                /* alp1 = L_mac (alp0, rr[i8][i8], _1_128, pOverflow); */
                alp1 = alp0 + ((Word32) * (p_temp2 + j) << 9);

                /* alp1 = L_mac (alp1, rr[i0][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i0][j] << 10;

                /* alp1 = L_mac (alp1, rr[i1][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i1][j] << 10;

                /* alp1 = L_mac (alp1, rr[i2][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i2][j] << 10;

                /* alp1 = L_mac (alp1, rr[i3][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i3][j] << 10;

                /* alp1 = L_mac (alp1, rr[i4][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i4][j] << 10;

                /* alp1 = L_mac (alp1, rr[i5][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i5][j] << 10;

                /* alp1 = L_mac (alp1, rr[i6][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i6][j] << 10;

                /* alp1 = L_mac (alp1, rr[i7][i8], _1_64, pOverflow); */
                alp1 += (Word32) rr[i7][j] << 10;

                p_temp1 = temp1;
                ps1 = dn[j];

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

                    /* sq2 = mult (ps2, ps2, pOverflow); */
                    sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);

                    /* alp2 = L_mac (alp1, rrv[i9], _1_8, pOverflow); */
                    alp2 = alp1 + ((Word32) * (p_temp2 + i9) << 10) ;

                    /* alp2 = L_mac (alp2, rr[i8][i9], _1_64, pOverflow); */
                    alp_16 = (Word16)((alp2 + ((Word32) * (p_temp1++) << 13)) >> 16);

                    if (((Word32) sq2 * alp) > ((Word32) sq * alp_16))
                    {
                        sq = sq2;
                        ps = ps2;
                        alp = alp_16;
                        ia = j;
                        ib = i9;
                    }
                }
            }

            index[8] = ia;
            index[9] = ib;

        }/* end  gsmefrFlag */

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

        if (((Word32) alpk * sq) > ((Word32) psk * alp))
        {
            psk = sq;
            alpk = alp;

            if (gsmefrFlag != 0)
            {
                oscl_memcpy(codvec, index, (2*NB_TRACK)*sizeof(*index));
            }
            else
            {
                oscl_memcpy(codvec, index, (2*NB_TRACK_MR102)*sizeof(*index));
            }

        }
        /*----------------------------------------------------------------*
        * 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[nbPulse-1] = pos;
    } /* end 1..nbTracks  loop*/
}