c4_17pf.cpp

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

/* ------------------------------------------------------------------
 * Copyright (C) 2008 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
/****************************************************************************************
Portions of this file are derived from the following 3GPP standard:

    3GPP TS 26.073
    ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
    Available from http://www.3gpp.org

(C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
Permission to distribute, modify and use this file under the standard license
terms listed above has been obtained from the copyright holder.
****************************************************************************************/
/*
------------------------------------------------------------------------------



 Pathname: ./audio/gsm-amr/c/src/c4_17pf.c
 Functions:

     Date: 05/26/2000

------------------------------------------------------------------------------
 REVISION HISTORY

 Description: Modified to pass overflow flag through to basic math function.
 The flag is passed back to the calling function by pointer reference.

 Description: Optimized functions to further reduce clock cycle usage.
              Updated copyright year, removed unnecessary include files,
              and removed unused #defines.

 Description: Changed round function name to pv_round to avoid conflict with
              round function in C standard library.

 Description:  Replaced "int" and/or "char" with OSCL defined types.

 Description: Added #ifdef __cplusplus around extern'ed table.

 Description:

------------------------------------------------------------------------------
 MODULE DESCRIPTION

 Purpose          : Searches a 17 bit algebraic codebook containing 4 pulses
                    in a frame of 40 samples
------------------------------------------------------------------------------
*/

/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/
#include "c4_17pf.h"
#include "typedef.h"
#include "inv_sqrt.h"
#include "cnst.h"
#include "cor_h.h"
#include "set_sign.h"
#include "basic_op.h"

/*--------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
{
#endif

    /*----------------------------------------------------------------------------
    ; MACROS
    ; Define module specific macros here
    ----------------------------------------------------------------------------*/

    /*----------------------------------------------------------------------------
    ; DEFINES
    ; Include all pre-processor statements here. Include conditional
    ; compile variables also.
    ----------------------------------------------------------------------------*/
#define NB_PULSE  4

    /*----------------------------------------------------------------------------
    ; LOCAL FUNCTION DEFINITIONS
    ; Function Prototype declaration
    ----------------------------------------------------------------------------*/

    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                 */
    );

    static Word16 build_code(
        Word16 codvec[],    /* i : algebraic codebook vector                     */
        Word16 dn_sign[],   /* i : sign of dn[]                                  */
        Word16 cod[],       /* o : algebraic (fixed) codebook excitation         */
        Word16 h[],         /* i : impulse response of weighted synthesis filter */
        Word16 y[],         /* o : filtered fixed codebook excitation            */
        Word16 sign[],      /* o : index of 4 pulses (position+sign+ampl)*4      */
        Flag   * pOverflow  /* o : Flag set when overflow occurs                 */
    );

    /*----------------------------------------------------------------------------
    ; LOCAL VARIABLE DEFINITIONS
    ; Variable declaration - defined here and used outside this module
    ----------------------------------------------------------------------------*/

    /*----------------------------------------------------------------------------
    ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
    ; Declare variables used in this module but defined elsewhere
    ----------------------------------------------------------------------------*/
    extern const Word16 gray[];
    extern const Word16 dgray[];

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

     Inputs:
        x[]   Array of type Word16 -- target vector
        h[]   Array of type Word16 -- impulse response of weighted synthesis filter
                                      h[-L_subfr..-1] must be set to zero.

        T0           Array of type Word16 -- Pitch lag
        pitch_sharp, Array of type Word16 --  Last quantized pitch gain

     Outputs:
        code[]  Array of type Word16 -- Innovative codebook
        y[]     Array of type Word16 -- filtered fixed codebook excitation
        * sign  Pointer of type Word16 -- Pointer to the signs of 4 pulses
        pOverflow    Pointer to Flag      -- set when overflow occurs

     Returns:
        index

     Global Variables Used:
        None

     Local Variables Needed:

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

     PURPOSE:  Searches a 17 bit algebraic codebook containing 4 pulses
               in a frame of 40 samples.

     DESCRIPTION:
       The code length is 40, containing 4 nonzero pulses: i0...i3.
       All pulses can have two possible amplitudes: +1 or -1.
       Pulse i0 to i2 can have 8 possible positions, pulse i3 can have
       2x8=16 positions.

          i0 :  0, 5, 10, 15, 20, 25, 30, 35.
          i1 :  1, 6, 11, 16, 21, 26, 31, 36.
          i2 :  2, 7, 12, 17, 22, 27, 32, 37.
          i3 :  3, 8, 13, 18, 23, 28, 33, 38.
                4, 9, 14, 19, 24, 29, 34, 39.

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

     None

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

     [1] c3_14pf.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]

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

    Word16 code_4i40_17bits(
        Word16 x[],         /* i : target vector                                 */
        Word16 h[],         /* i : impulse response of weighted synthesis filter */
        /*     h[-L_subfr..-1] must be set to zero.          */
        Word16 T0,          /* i : Pitch lag                                     */
        Word16 pitch_sharp, /* i : Last quantized pitch gain                     */
        Word16 code[],      /* o : Innovative codebook                           */
        Word16 y[],         /* o : filtered fixed codebook excitation            */
        Word16 * sign,      /* o : Signs of 4 pulses                             */
        Flag   * pOverflow  /* o : Flag set when overflow occurs                 */
    )
    {
        Word16 codvec[NB_PULSE];
        Word16 dn[L_CODE];
        Word16 dn2[L_CODE];
        Word16 dn_sign[L_CODE];

        Word16 rr[L_CODE][L_CODE];
        Word16 i;
        Word16 index;
        Word16 sharp;
        Word16 tempWord;

        sharp = pitch_sharp << 1;

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

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

        cor_h_x(
            h,
            x,
            dn,
            1,
            pOverflow);

        set_sign(
            dn,
            dn_sign,
            dn2,
            4);

        cor_h(
            h,
            dn_sign,
            rr,
            pOverflow);

        search_4i40(
            dn,
            dn2,
            rr,
            codvec,
            pOverflow);

        /* function result */
        index =
            build_code(
                codvec,
                dn_sign,
                code,
                h,
                y,
                sign,
                pOverflow);

        /*-----------------------------------------------------------------*
        * Compute innovation vector gain.                                 *
        * Include fixed-gain pitch contribution into code[].              *
        *-----------------------------------------------------------------*/

        tempWord = T0 - L_CODE;