c4_17pf.cpp

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

        if (tempWord < 0)
        {
            for (i = T0; i < L_CODE; i++)
            {
                tempWord =
                    mult(
                        code[i - T0],
                        sharp,
                        pOverflow);

                code[i] =
                    add(
                        code[i],
                        tempWord,
                        pOverflow);
            }
        }

        return index;
    }
    /****************************************************************************/

    /*
    ------------------------------------------------------------------------------
     FUNCTION NAME: search_4i40()
    ------------------------------------------------------------------------------
     INPUT AND OUTPUT DEFINITIONS

     Inputs:
        dn[]         Array of type Word16 -- correlation between target and h[]
        dn2[]        Array of type Word16 -- maximum of corr. in each track.
        rr[][L_CODE] Double Array of type Word16 -- autocorrelation matrix

     Outputs:
        codvec[]     Array of type Word16 -- algebraic codebook vector
        pOverflow    Pointer to Flag      -- set when overflow occurs

     Returns:


     Global Variables Used:
        None

     Local Variables Needed:


    ------------------------------------------------------------------------------
     FUNCTION DESCRIPTION

     PURPOSE: Search the best codevector; determine positions of the 4 pulses
              in the 40-sample frame.

    ------------------------------------------------------------------------------
     REQUIREMENTS

     None

    ------------------------------------------------------------------------------
     REFERENCES

     [1] c4_17pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

    ------------------------------------------------------------------------------
     PSEUDO-CODE

    ------------------------------------------------------------------------------
     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]

    ------------------------------------------------------------------------------
    */
    static void search_4i40(
        Word16 dn[],         /* i : correlation between target and h[]  */
        Word16 dn2[],        /* i : maximum of corr. in each track.     */
        Word16 rr[][L_CODE], /* i : matrix of autocorrelation           */
        Word16 codvec[],     /* o : algebraic codebook vector           */
        Flag   * pOverflow   /* o : Flag set when overflow occurs       */
    )
    {
        Word16 i0;
        Word16 i1;
        Word16 i2;
        Word16 i3;

        Word16 ix = 0; /* initialization only needed to keep gcc silent */
        Word16 ps = 0; /* initialization only needed to keep gcc silent */

        Word16 i;
        Word16 pos;
        Word16 track;
        Word16 ipos[NB_PULSE];

        Word16 psk;
        Word16 ps0;
        Word16 ps1;
        Word16 sq;
        Word16 sq1;

        Word16 alpk;
        Word16 alp;
        Word16 alp_16;
        Word16 *p_codvec = &codvec[0];

        Word32 s;
        Word32 alp0;
        Word32 alp1;

        OSCL_UNUSED_ARG(pOverflow);

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

        for (track = 3; track < 5; track++)
        {
            /* fix starting position */

            ipos[0] = 0;
            ipos[1] = 1;
            ipos[2] = 2;
            ipos[3] = track;

            /*------------------------------------------------------------------*
             * main loop: try 4 tracks.                                         *
             *------------------------------------------------------------------*/

            for (i = 0; i < NB_PULSE; i++)
            {
                /*----------------------------------------------------------------*
                 * i0 loop: try 4 positions (use position with max of corr.).     *
                 *----------------------------------------------------------------*/

                for (i0 = ipos[0]; i0 < L_CODE; i0 += STEP)
                {
                    if (dn2[i0] >= 0)
                    {
                        ps0 = dn[i0];

                        alp0 = (Word32) rr[i0][i0] << 14;

                        /*----------------------------------------------------------------*
                         * i1 loop: 8 positions.                                          *
                         *----------------------------------------------------------------*/

                        sq = -1;
                        alp = 1;
                        ps = 0;
                        ix = ipos[1];

                        /* 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][i3]" is a pointer initialized to "&rr[i0][ipos[3]]"      *
                         *  and incremented by "STEP".                                       *
                         *-------------------------------------------------------------------*/

                        for (i1 = ipos[1]; i1 < L_CODE; i1 += STEP)
                        {
                            /* idx increment = STEP */
                            /* ps1 = add(ps0, dn[i1], pOverflow); */
                            ps1 = ps0 + dn[i1];

                            /* alp1 = alp0 + rr[i0][i1] + 1/2*rr[i1][i1]; */

                            /* alp1 = L_mac(alp0, rr[i1][i1], _1_4, pOverflow); */
                            alp1 = alp0 + ((Word32) rr[i1][i1] << 14);

                            /* alp1 = L_mac(alp1, rr[i0][i1], _1_2, pOverflow); */
                            alp1 += (Word32) rr[i0][i1] << 15;

                            /* sq1 = mult(ps1, ps1, pOverflow); */
                            sq1 = (Word16)(((Word32) ps1 * ps1) >> 15);

                            /* alp_16 = pv_round(alp1, pOverflow); */
                            alp_16 = (Word16)((alp1 + (Word32) 0x00008000L) >> 16);

                            /* s = L_mult(alp, sq1, pOverflow); */
                            s = ((Word32) alp * sq1) << 1;

                            /* s = L_msu(s, sq, alp_16, pOverflow); */
                            s -= (((Word32) sq * alp_16) << 1);

                            if (s > 0)
                            {
                                sq = sq1;
                                ps = ps1;
                                alp = alp_16;
                                ix = i1;
                            }
                        }
                        i1 = ix;

                        /*----------------------------------------------------------------*
                         * i2 loop: 8 positions.                                          *
                         *----------------------------------------------------------------*/

                        ps0 = ps;

                        /* alp0 = L_mult(alp, _1_4, pOverflow); */
                        alp0 = (Word32) alp << 14;

                        sq = -1;
                        alp = 1;
                        ps = 0;
                        ix = ipos[2];

                        /* initialize 4 index for next loop (see i1 loop) */

                        for (i2 = ipos[2]; i2 < L_CODE; i2 += STEP)
                        {
                            /* index increment = STEP */
                            /* ps1 = add(ps0, dn[i2], pOverflow); */
                            ps1 = ps0 + dn[i2];

                            /* alp1 = alp0 + rr[i0][i2] + rr[i1][i2] + 1/2*rr[i2][i2]; */

                            /* idx incr = STEP */
                            /* alp1 = L_mac(alp0, rr[i2][i2], _1_16, pOverflow); */
                            alp1 = alp0 + ((Word32) rr[i2][i2] << 12);

                            /* idx incr = STEP */
                            /* alp1 = L_mac(alp1, rr[i1][i2], _1_8, pOverflow); */
                            alp1 += (Word32) rr[i1][i2] << 13;

                            /* idx incr = STEP */
                            /* alp1 = L_mac(alp1,rr[i0][i2], _1_8, pOverflow); */
                            alp1 += (Word32) rr[i0][i2] << 13;

                            /* sq1 = mult(ps1, ps1, pOverflow); */
                            sq1 = (Word16)(((Word32) ps1 * ps1) >> 15);

                            /* alp_16 = pv_round(alp1, pOverflow); */
                            alp_16 = (Word16)((alp1 + (Word32) 0x00008000L) >> 16);

                            /* s = L_mult(alp, sq1, pOverflow); */
                            s = ((Word32) alp * sq1) << 1;

                            /* s = L_msu(s, sq, alp_16, pOverflow); */
                            s -= (((Word32) sq * alp_16) << 1);

                            if (s > 0)
                            {
                                sq = sq1;
                                ps = ps1;
                                alp = alp_16;
                                ix = i2;
                            }
                        }
                        i2 = ix;

                        /*----------------------------------------------------------------*
                         * i3 loop: 8 positions.                                          *
                         *----------------------------------------------------------------*/

                        ps0 = ps;
                        alp0 = L_deposit_h(alp);

                        sq = -1;
                        alp = 1;
                        ps = 0;
                        ix = ipos[3];

                        /* initialize 5 index for next loop (see i1 loop) */

                        for (i3 = ipos[3]; i3 < L_CODE; i3 += STEP)
                        {
                            /* ps1 = add(ps0, dn[i3], pOverflow); */
                            ps1 = ps0 + dn[i3]; /* index increment = STEP */

                            /* alp1 = alp0 + rr[i0][i3] + rr[i1][i3] + rr[i2][i3] + 1/2*rr[i3][i3]; */

                            /* alp1 = L_mac(alp0, rr[i3][i3], _1_16, pOverflow); */
                            alp1 = alp0 + ((Word32) rr[i3][i3] << 12); /* idx incr = STEP */

                            /* alp1 = L_mac(alp1, rr[i2][i3], _1_8, pOverflow); */
                            alp1 += (Word32) rr[i2][i3] << 13;  /* idx incr = STEP */