c4_17pf.cpp

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

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

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

                            /* 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 = i3;
                            }
                        }


                        /*----------------------------------------------------------------*
                         * memorise codevector if this one is better than the last one.   *
                         *----------------------------------------------------------------*/

                        /* s = L_mult(alpk, sq, pOverflow); */
                        s = ((Word32) alpk * sq) << 1;

                        /* s = L_msu(s, psk, alp, pOverflow); */
                        s -= (((Word32) psk * alp) << 1);

                        if (s > 0)
                        {
                            psk = sq;
                            alpk = alp;
                            p_codvec = &codvec[0];

                            *(p_codvec++) = i0;
                            *(p_codvec++) = i1;
                            *(p_codvec++) = i2;
                            *(p_codvec) = ix;
                        }
                    }
                }

                /*----------------------------------------------------------------*
                 * Cyclic permutation of i0,i1,i2 and i3.                         *
                 *----------------------------------------------------------------*/

                pos = ipos[3];
                ipos[3] = ipos[2];
                ipos[2] = ipos[1];
                ipos[1] = ipos[0];
                ipos[0] = pos;
            }
        }

        return;
    }




    /****************************************************************************/

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

     Inputs:
        codvec[]   Array of type Word16 -- position of pulses
        dn_sign[]  Array of type Word16 -- sign of pulses
        h[]        Array of type Word16 -- impulse response of
                                           weighted synthesis filter

     Outputs:
        cod[]  Array of type Word16 -- innovative code vector
        y[]    Array of type Word16 -- filtered innovative code
        sign[] Array of type Word16 -- index of 4 pulses (sign + position)
        pOverflow  Pointer to Flag  -- set when overflow occurs

     Returns:
        indx

     Global Variables Used:
        None

     Local Variables Needed:

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

     PURPOSE: Builds the codeword, the filtered codeword and index of the
              codevector, based on the signs and positions of 4 pulses.

    ------------------------------------------------------------------------------
     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 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 : index of 4 pulses (sign+position)             */
        Flag   * pOverflow  /* o : Flag set when overflow occurs               */
    )
    {
        Word16 i;
        Word16 j;
        Word16 k;
        Word16 track;
        Word16 index;
        Word16 _sign[NB_PULSE];
        Word16 indx;
        Word16 rsign;

        Word16 *p0;
        Word16 *p1;
        Word16 *p2;
        Word16 *p3;
        Word16 *p_cod = &cod[0];

        Word32 s;

        for (i = 0; i < L_CODE; i++)
        {
            *(p_cod++) = 0;
        }

        indx = 0;
        rsign = 0;

        for (k = 0; k < NB_PULSE; k++)
        {
            i = codvec[k]; /* read pulse position */
            j = dn_sign[i]; /* read sign          */

            /* index = pos/5 */
            /* index = mult(i, 6554, pOverflow); */
            index = (Word16)(((Word32) i * 6554) >> 15);

            /* track = pos%5 */
            /* s = L_mult(index, 5, pOverflow); */
            s = ((Word32) index * 5) << 1;

            /* s = L_shr(s, 1, pOverflow); */
            s >>= 1;

            /* track = sub(i, (Word16) s, pOverflow); */
            track = i - (Word16) s;

            index = gray[index];

            if (track == 1)
            {
                /* index = shl(index, 3, pOverflow); */
                index <<= 3;
            }
            else if (track == 2)
            {
                /* index = shl(index, 6, pOverflow); */
                index <<= 6;
            }
            else if (track == 3)
            {
                /* index = shl(index, 10, pOverflow); */
                index <<= 10;
            }
            else if (track == 4)
            {
                track = 3;

                /* index = shl(index, 10, pOverflow); */
                index <<= 10;

                /* index = add(index, 512, pOverflow); */
                index += 512;
            }

            if (j > 0)
            {
                cod[i] = 8191;
                _sign[k] = 32767;

                /* track = shl(1, track, pOverflow); */
                track = 1 << track;

                /* rsign = add(rsign, track, pOverflow); */
                rsign += track;
            }
            else
            {
                cod[i] = -8192;
                _sign[k] = (Word16) - 32768L;
            }

            /* indx = add(indx, index, pOverflow); */
            indx += index;
        }
        *sign = rsign;

        p0 = h - codvec[0];
        p1 = h - codvec[1];
        p2 = h - codvec[2];
        p3 = h - codvec[3];

        for (i = 0; i < L_CODE; i++)
        {
            s = 0;
            s =
                L_mac(
                    s,
                    *p0++,
                    _sign[0],
                    pOverflow);

            s =
                L_mac(
                    s,
                    *p1++,
                    _sign[1],
                    pOverflow);

            s =
                L_mac(
                    s,
                    *p2++,
                    _sign[2],
                    pOverflow);

            s =
                L_mac(
                    s,
                    *p3++,
                    _sign[3],
                    pOverflow);

            y[i] =
                pv_round(
                    s,
                    pOverflow);

        } /* for (i = 0; i < L_CODE; i++) */

        return indx;

    } /* build_code */

#ifdef __cplusplus
}
#endif