/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 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/qgain475.c
 Funtions: MR475_quant_store_results
           MR475_update_unq_pred
           MR475_gain_quant

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

 These modules handle the quantization of pitch and codebook gains for MR475.

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


/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/
#include "qgain475.h"
#include "typedef.h"
#include "basic_op.h"
#include "mode.h"
#include "cnst.h"
#include "pow2.h"
#include "log2.h"

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


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

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

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

/* The table contains the following data:
 *
 *    g_pitch(0)        (Q14) // for sub-
 *    g_fac(0)          (Q12) // frame 0 and 2
 *    g_pitch(1)        (Q14) // for sub-
 *    g_fac(2)          (Q12) // frame 1 and 3
 *
 */
static const Word16 table_gain_MR475[MR475_VQ_SIZE*4] =
{
    /*g_pit(0), g_fac(0),      g_pit(1), g_fac(1) */
    812,          128,           542,      140,
    2873,         1135,          2266,     3402,
    2067,          563,         12677,      647,
    4132,         1798,          5601,     5285,
    7689,          374,          3735,      441,
    10912,         2638,         11807,     2494,
    20490,          797,          5218,      675,
    6724,         8354,          5282,     1696,
    1488,          428,          5882,      452,
    5332,         4072,          3583,     1268,
    2469,          901,         15894,     1005,
    14982,         3271,         10331,     4858,
    3635,         2021,          2596,      835,
    12360,         4892,         12206,     1704,
    13432,         1604,          9118,     2341,
    3968,         1538,          5479,     9936,
    3795,          417,          1359,      414,
    3640,         1569,          7995,     3541,
    11405,          645,          8552,      635,
    4056,         1377,         16608,     6124,
    11420,          700,          2007,      607,
    12415,         1578,         11119,     4654,
    13680,         1708,         11990,     1229,
    7996,         7297,         13231,     5715,
    2428,         1159,          2073,     1941,
    6218,         6121,          3546,     1804,
    8925,         1802,          8679,     1580,
    13935,         3576,         13313,     6237,
    6142,         1130,          5994,     1734,
    14141,         4662,         11271,     3321,
    12226,         1551,         13931,     3015,
    5081,        10464,          9444,     6706,
    1689,          683,          1436,     1306,
    7212,         3933,          4082,     2713,
    7793,          704,         15070,      802,
    6299,         5212,          4337,     5357,
    6676,          541,          6062,      626,
    13651,         3700,         11498,     2408,
    16156,          716,         12177,      751,
    8065,        11489,          6314,     2256,
    4466,          496,          7293,      523,
    10213,         3833,          8394,     3037,
    8403,          966,         14228,     1880,
    8703,         5409,         16395,     4863,
    7420,         1979,          6089,     1230,
    9371,         4398,         14558,     3363,
    13559,         2873,         13163,     1465,
    5534,         1678,         13138,    14771,
    7338,          600,          1318,      548,
    4252,         3539,         10044,     2364,
    10587,          622,         13088,      669,
    14126,         3526,          5039,     9784,
    15338,          619,          3115,      590,
    16442,         3013,         15542,     4168,
    15537,         1611,         15405,     1228,
    16023,         9299,          7534,     4976,
    1990,         1213,         11447,     1157,
    12512,         5519,          9475,     2644,
    7716,         2034,         13280,     2239,
    16011,         5093,          8066,     6761,
    10083,         1413,          5002,     2347,
    12523,         5975,         15126,     2899,
    18264,         2289,         15827,     2527,
    16265,        10254,         14651,    11319,
    1797,          337,          3115,      397,
    3510,         2928,          4592,     2670,
    7519,          628,         11415,      656,
    5946,         2435,          6544,     7367,
    8238,          829,          4000,      863,
    10032,         2492,         16057,     3551,
    18204,         1054,          6103,     1454,
    5884,         7900,         18752,     3468,
    1864,          544,          9198,      683,
    11623,         4160,          4594,     1644,
    3158,         1157,         15953,     2560,
    12349,         3733,         17420,     5260,
    6106,         2004,          2917,     1742,
    16467,         5257,         16787,     1680,
    17205,         1759,          4773,     3231,
    7386,         6035,         14342,    10012,
    4035,          442,          4194,      458,
    9214,         2242,          7427,     4217,
    12860,          801,         11186,      825,
    12648,         2084,         12956,     6554,
    9505,          996,          6629,      985,
    10537,         2502,         15289,     5006,
    12602,         2055,         15484,     1653,
    16194,         6921,         14231,     5790,
    2626,          828,          5615,     1686,
    13663,         5778,          3668,     1554,
    11313,         2633,          9770,     1459,
    14003,         4733,         15897,     6291,
    6278,         1870,          7910,     2285,
    16978,         4571,         16576,     3849,
    15248,         2311,         16023,     3244,
    14459,        17808,         11847,     2763,
    1981,         1407,          1400,      876,
    4335,         3547,          4391,     4210,
    5405,          680,         17461,      781,
    6501,         5118,          8091,     7677,
    7355,          794,          8333,     1182,
    15041,         3160,         14928,     3039,
    20421,          880,         14545,      852,
    12337,        14708,          6904,     1920,
    4225,          933,          8218,     1087,
    10659,         4084,         10082,     4533,
    2735,          840,         20657,     1081,
    16711,         5966,         15873,     4578,
    10871,         2574,          3773,     1166,
    14519,         4044,         20699,     2627,
    15219,         2734,         15274,     2186,
    6257,         3226,         13125,    19480,
    7196,          930,          2462,     1618,
    4515,         3092,         13852,     4277,
    10460,          833,         17339,      810,
    16891,         2289,         15546,     8217,
    13603,         1684,          3197,     1834,
    15948,         2820,         15812,     5327,
    17006,         2438,         16788,     1326,
    15671,         8156,         11726,     8556,
    3762,         2053,          9563,     1317,
    13561,         6790,         12227,     1936,
    8180,         3550,         13287,     1778,
    16299,         6599,         16291,     7758,
    8521,         2551,          7225,     2645,
    18269,         7489,         16885,     2248,
    17882,         2884,         17265,     3328,
    9417,        20162,         11042,     8320,
    1286,          620,          1431,      583,
    5993,         2289,          3978,     3626,
    5144,          752,         13409,      830,
    5553,         2860,         11764,     5908,
    10737,          560,          5446,      564,
    13321,         3008,         11946,     3683,
    19887,          798,          9825,      728,
    13663,         8748,          7391,     3053,
    2515,          778,          6050,      833,
    6469,         5074,          8305,     2463,
    6141,         1865,         15308,     1262,
    14408,         4547,         13663,     4515,
    3137,         2983,          2479,     1259,
    15088,         4647,         15382,     2607,
    14492,         2392,         12462,     2537,
    7539,         2949,         12909,    12060,
    5468,          684,          3141,      722,
    5081,         1274,         12732,     4200,
    15302,          681,          7819,      592,
    6534,         2021,         16478,     8737,
    13364,          882,          5397,      899,
    14656,         2178,         14741,     4227,
    14270,         1298,         13929,     2029,
    15477,         7482,         15815,     4572,
    2521,         2013,          5062,     1804,
    5159,         6582,          7130,     3597,
    10920,         1611,         11729,     1708,
    16903,         3455,         16268,     6640,
    9306,         1007,          9369,     2106,
    19182,         5037,         12441,     4269,
    15919,         1332,         15357,     3512,
    11898,        14141,         16101,     6854,
    2010,          737,          3779,      861,
    11454,         2880,          3564,     3540,
    9057,         1241,         12391,      896,
    8546,         4629,         11561,     5776,
    8129,          589,          8218,      588,
    18728,         3755,         12973,     3149,
    15729,          758,         16634,      754,
    15222,        11138,         15871,     2208,
    4673,          610,         10218,      678,
    15257,         4146,          5729,     3327,
    8377,         1670,         19862,     2321,
    15450,         5511,         14054,     5481,
    5728,         2888,          7580,     1346,
    14384,         5325,         16236,     3950,
    15118,         3744,         15306,     1435,
    14597,         4070,         12301,    15696,
    7617,         1699,          2170,      884,
    4459,         4567,         18094,     3306,
    12742,          815,         14926,      907,
    15016,         4281,         15518,     8368,
    17994,         1087,          2358,      865,
    16281,         3787,         15679,     4596,
    16356,         1534,         16584,     2210,
    16833,         9697,         15929,     4513,
    3277,         1085,          9643,     2187,
    11973,         6068,          9199,     4462,
    8955,         1629,         10289,     3062,
    16481,         5155,         15466,     7066,
    13678,         2543,          5273,     2277,
    16746,         6213,         16655,     3408,
    20304,         3363,         18688,     1985,
    14172,        12867,         15154,    15703,
    4473,         1020,          1681,      886,
    4311,         4301,          8952,     3657,
    5893,         1147,         11647,     1452,
    15886,         2227,          4582,     6644,
    6929,         1205,          6220,      799,
    12415,         3409,         15968,     3877,
    19859,         2109,          9689,     2141,
    14742,         8830,         14480,     2599,
    1817,         1238,          7771,      813,
    19079,         4410,          5554,     2064,
    3687,         2844,         17435,     2256,
    16697,         4486,         16199,     5388,
    8028,         2763,          3405,     2119,
    17426,         5477,         13698,     2786,
    19879,         2720,          9098,     3880,
    18172,         4833,         17336,    12207,
    5116,          996,          4935,      988,
    9888,         3081,          6014,     5371,
    15881,         1667,          8405,     1183,
    15087,         2366,         19777,     7002,
    11963,         1562,          7279,     1128,
    16859,         1532,         15762,     5381,
    14708,         2065,         20105,     2155,
    17158,         8245,         17911,     6318,
    5467,         1504,          4100,     2574,
    17421,         6810,          5673,     2888,
    16636,         3382,          8975,     1831,
    20159,         4737,         19550,     7294,
    6658,         2781,         11472,     3321,
    19397,         5054,         18878,     4722,
    16439,         2373,         20430,     4386,
    11353,        26526,         11593,     3068,
    2866,         1566,          5108,     1070,
    9614,         4915,          4939,     3536,
    7541,          878,         20717,      851,
    6938,         4395,         16799,     7733,
    10137,         1019,          9845,      964,
    15494,         3955,         15459,     3430,
    18863,          982,         20120,      963,
    16876,        12887,         14334,     4200,
    6599,         1220,          9222,      814,
    16942,         5134,          5661,     4898,
    5488,         1798,         20258,     3962,
    17005,         6178,         17929,     5929,
    9365,         3420,          7474,     1971,
    19537,         5177,         19003,     3006,
    16454,         3788,         16070,     2367,
    8664,         2743,          9445,    26358,
    10856,         1287,          3555,     1009,
    5606,         3622,         19453,     5512,
    12453,          797,         20634,      911,
    15427,         3066,         17037,    10275,
    18883,         2633,          3913,     1268,
    19519,         3371,         18052,     5230,
    19291,         1678,         19508,     3172,
    18072,        10754,         16625,     6845,
    3134,         2298,         10869,     2437,
    15580,         6913,         12597,     3381,
    11116,         3297,         16762,     2424,
    18853,         6715,         17171,     9887,
    12743,         2605,          8937,     3140,
    19033,         7764,         18347,     3880,
    20475,         3682,         19602,     3380,
    13044,        19373,         10526,    23124
};

/*
------------------------------------------------------------------------------
 FUNCTION NAME: MR475_quant_store_results
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    pred_st = pointer to structure of type gc_predState
    p = pointer to selected quantizer table entry (const Word16)
    gcode0 = predicted CB gain (Word16)
    exp_gcode0 = exponent of predicted CB gain (Word16)
    gain_pit = pointer to Pitch gain (Word16)
    gain_cod = pointer to Code gain (Word16)

 Outputs:
    pred_st points to the updated structure of type gc_predState
    gain_pit points to Pitch gain
    gain_cod points to Code gain
    pOverflow points to overflow indicator (Flag)

 Returns:
    None.

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This function calculates the final fixed codebook gain and the predictor
 update values, and updates the gain predictor.

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

 None.

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

 qgain475.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

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

static void MR475_quant_store_results(

    gc_predState *pred_st, // i/o: gain predictor state struct
    const Word16 *p,       // i  : pointer to selected quantizer table entry
    Word16 gcode0,         // i  : predicted CB gain,     Q(14 - exp_gcode0)
    Word16 exp_gcode0,     // i  : exponent of predicted CB gain,        Q0
    Word16 *gain_pit,      // o  : Pitch gain,                           Q14
    Word16 *gain_cod       // o  : Code gain,                            Q1
)
{

    Word16 g_code, exp, frac, tmp;
    Word32 L_tmp;

    Word16 qua_ener_MR122; // o  : quantized energy error, MR122 version Q10
    Word16 qua_ener;       // o  : quantized energy error,               Q10

    // Read the quantized gains
    *gain_pit = *p++;
    g_code = *p++;

    //------------------------------------------------------------------*
     *  calculate final fixed codebook gain:                            *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                            *
     *                                                                  *
     *   gc = gc0 * g                                                   *
     *------------------------------------------------------------------

    L_tmp = L_mult(g_code, gcode0);
    L_tmp = L_shr(L_tmp, sub(10, exp_gcode0));
    *gain_cod = extract_h(L_tmp);

    //------------------------------------------------------------------*
     *  calculate predictor update values and update gain predictor:    *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    *
     *                                                                  *
     *   qua_ener       = log2(g)                                       *
     *   qua_ener_MR122 = 20*log10(g)                                   *
     *------------------------------------------------------------------

    Log2 (L_deposit_l (g_code), &exp, &frac); // Log2(x Q12) = log2(x) + 12
    exp = sub(exp, 12);

    tmp = shr_r (frac, 5);
    qua_ener_MR122 = add (tmp, shl (exp, 10));

    L_tmp = Mpy_32_16(exp, frac, 24660); // 24660 Q12 ~= 6.0206 = 20*log10(2)
    qua_ener = pv_round (L_shl (L_tmp, 13)); // Q12 * Q0 = Q13 -> Q10

    gc_pred_update(pred_st, qua_ener_MR122, qua_ener);
}

------------------------------------------------------------------------------
 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 MR475_quant_store_results(
    gc_predState *pred_st, /* i/o: gain predictor state struct               */
    const Word16 *p,       /* i  : pointer to selected quantizer table entry */
    Word16 gcode0,         /* i  : predicted CB gain,     Q(14 - exp_gcode0) */
    Word16 exp_gcode0,     /* i  : exponent of predicted CB gain,        Q0  */
    Word16 *gain_pit,      /* o  : Pitch gain,                           Q14 */
    Word16 *gain_cod,      /* o  : Code gain,                            Q1  */
    Flag   *pOverflow      /* o  : overflow indicator                        */
)
{
    Word16 g_code;
    Word16 exp;
    Word16 frac;
    Word16 tmp;
    Word32 L_tmp;

    Word16 qua_ener_MR122; /* o  : quantized energy error, MR122 version Q10 */
    Word16 qua_ener;       /* o  : quantized energy error,               Q10 */


    /* Read the quantized gains */
    *gain_pit = *p++;
    g_code = *p++;

    /*------------------------------------------------------------------*
     *  calculate final fixed codebook gain:                            *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                            *
     *                                                                  *
     *   gc = gc0 * g                                                   *
     *------------------------------------------------------------------*/

    L_tmp = ((Word32) g_code * gcode0) << 1;
    tmp   = 10 - exp_gcode0;
    L_tmp = L_shr(L_tmp, tmp, pOverflow);
    *gain_cod = (Word16)(L_tmp >> 16);

    /*------------------------------------------------------------------*
     *  calculate predictor update values and update gain predictor:    *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    *
     *                                                                  *
     *   qua_ener       = log2(g)                                       *
     *   qua_ener_MR122 = 20*log10(g)                                   *
     *------------------------------------------------------------------*/

    /* Log2(x Q12) = log2(x) + 12 */
    Log2((Word32) g_code, &exp, &frac, pOverflow);
    exp -= 12;

    tmp = shr_r(frac, 5, pOverflow);
    qua_ener_MR122 = exp << 10;
    qua_ener_MR122 = tmp + qua_ener_MR122;

    /* 24660 Q12 ~= 6.0206 = 20*log10(2) */
    L_tmp = Mpy_32_16(exp, frac, 24660, pOverflow);
    L_tmp = L_tmp << 13;

    /* Q12 * Q0 = Q13 -> Q10 */
    qua_ener = (Word16)((L_tmp + (Word32) 0x00008000L) >> 16);

    gc_pred_update(pred_st, qua_ener_MR122, qua_ener);

    return;
}

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


/*
------------------------------------------------------------------------------
 FUNCTION NAME: MR475_update_unq_pred
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    pred_st = pointer to structure of type gc_predState
    exp_gcode0 = predicted CB gain (exponent MSW) (Word16)
    frac_gcode0 = predicted CB gain (exponent LSW) (Word16)
    cod_gain_exp = optimum codebook gain (exponent)(Word16)
    cod_gain_frac = optimum codebook gain (fraction) (Word16)

 Outputs:
    pred_st points to the updated structure of type gc_predState
    pOverflow points to overflow indicator (Flag)

 Returns:
    None.

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This module uses the optimum codebook gain and updates the "unquantized"
 gain predictor with the (bounded) prediction error.

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

 None.

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

 qgain475.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

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

void
MR475_update_unq_pred(
    gc_predState *pred_st, // i/o: gain predictor state struct
    Word16 exp_gcode0,     // i  : predicted CB gain (exponent MSW),  Q0
    Word16 frac_gcode0,    // i  : predicted CB gain (exponent LSW),  Q15
    Word16 cod_gain_exp,   // i  : optimum codebook gain (exponent),  Q0
    Word16 cod_gain_frac   // i  : optimum codebook gain (fraction),  Q15
)
{
    Word16 tmp, exp, frac;
    Word16 qua_ener, qua_ener_MR122;
    Word32 L_tmp;

    // calculate prediction error factor (given optimum CB gain gcu):
    //   predErrFact = gcu / gcode0
    //   (limit to MIN_PRED_ERR_FACT <= predErrFact <= MAX_PRED_ERR_FACT
    //    -> limit qua_ener*)
    //
    // calculate prediction error (log):
    //
    //   qua_ener_MR122 = log2(predErrFact)
    //   qua_ener       = 20*log10(predErrFact)

    if (cod_gain_frac <= 0)
    {
        // if gcu <= 0 -> predErrFact = 0 < MIN_PRED_ERR_FACT
        // -> set qua_ener(_MR122) directly
        qua_ener = MIN_QUA_ENER;
        qua_ener_MR122 = MIN_QUA_ENER_MR122;
    }
    else
    {
        // convert gcode0 from DPF to standard fraction/exponent format
        // with normalized frac, i.e. 16384 <= frac <= 32767
        // Note: exponent correction (exp=exp-14) is done after div_s
        frac_gcode0 = extract_l (Pow2 (14, frac_gcode0));

        // make sure cod_gain_frac < frac_gcode0  for div_s
        if (sub(cod_gain_frac, frac_gcode0) >= 0)
        {
            cod_gain_frac = shr (cod_gain_frac, 1);
            cod_gain_exp = add (cod_gain_exp, 1);
        }

        // predErrFact
        //   = gcu / gcode0
        //   = cod_gain_frac/frac_gcode0 * 2^(cod_gain_exp-(exp_gcode0-14))
        //   = div_s (c_g_f, frac_gcode0)*2^-15 * 2^(c_g_e-exp_gcode0+14)
        //   = div_s * 2^(cod_gain_exp-exp_gcode0 - 1)

        frac = div_s (cod_gain_frac, frac_gcode0);
        tmp = sub (sub (cod_gain_exp, exp_gcode0), 1);

        Log2 (L_deposit_l (frac), &exp, &frac);
        exp = add (exp, tmp);

        // calculate prediction error (log2, Q10)
        qua_ener_MR122 = shr_r (frac, 5);
        qua_ener_MR122 = add (qua_ener_MR122, shl (exp, 10));

        if (sub(qua_ener_MR122, MIN_QUA_ENER_MR122) < 0)
        {
            qua_ener = MIN_QUA_ENER;
            qua_ener_MR122 = MIN_QUA_ENER_MR122;
        }
        else if (sub(qua_ener_MR122, MAX_QUA_ENER_MR122) > 0)
        {
            qua_ener = MAX_QUA_ENER;
            qua_ener_MR122 = MAX_QUA_ENER_MR122;
        }
        else
        {
            // calculate prediction error (20*log10, Q10)
            L_tmp = Mpy_32_16(exp, frac, 24660);
            // 24660 Q12 ~= 6.0206 = 20*log10(2)
            qua_ener = pv_round (L_shl (L_tmp, 13));
            // Q12 * Q0 = Q13 -> Q26 -> Q10
        }
    }

    // update MA predictor memory
    gc_pred_update(pred_st, qua_ener_MR122, qua_ener);
}

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

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

void MR475_update_unq_pred(
    gc_predState *pred_st, /* i/o: gain predictor state struct            */
    Word16 exp_gcode0,     /* i  : predicted CB gain (exponent MSW),  Q0  */
    Word16 frac_gcode0,    /* i  : predicted CB gain (exponent LSW),  Q15 */
    Word16 cod_gain_exp,   /* i  : optimum codebook gain (exponent),  Q0  */
    Word16 cod_gain_frac,  /* i  : optimum codebook gain (fraction),  Q15 */
    Flag   *pOverflow      /* o  : overflow indicator                     */
)
{
    Word16 tmp;
    Word16 exp;
    Word16 frac;
    Word16 qua_ener;
    Word16 qua_ener_MR122;
    Word32 L_tmp;

    /* calculate prediction error factor (given optimum CB gain gcu):
     *
     *   predErrFact = gcu / gcode0
     *   (limit to MIN_PRED_ERR_FACT <= predErrFact <= MAX_PRED_ERR_FACT
     *    -> limit qua_ener*)
     *
     * calculate prediction error (log):
     *
     *   qua_ener_MR122 = log2(predErrFact)
     *   qua_ener       = 20*log10(predErrFact)
     *
     */

    if (cod_gain_frac <= 0)
    {
        /* if gcu <= 0 -> predErrFact = 0 < MIN_PRED_ERR_FACT */
        /* -> set qua_ener(_MR122) directly                   */
        qua_ener = MIN_QUA_ENER;
        qua_ener_MR122 = MIN_QUA_ENER_MR122;
    }
    else
    {
        /* convert gcode0 from DPF to standard fraction/exponent format */
        /* with normalized frac, i.e. 16384 <= frac <= 32767            */
        /* Note: exponent correction (exp=exp-14) is done after div_s   */
        frac_gcode0 = (Word16)(Pow2(14, frac_gcode0, pOverflow));

        /* make sure cod_gain_frac < frac_gcode0  for div_s */
        if (cod_gain_frac >= frac_gcode0)
        {
            cod_gain_frac >>= 1;
            cod_gain_exp += 1;
        }

        /*
          predErrFact
             = gcu / gcode0
             = cod_gain_frac/frac_gcode0 * 2^(cod_gain_exp-(exp_gcode0-14))
             = div_s (c_g_f, frac_gcode0)*2^-15 * 2^(c_g_e-exp_gcode0+14)
             = div_s * 2^(cod_gain_exp-exp_gcode0 - 1)
        */
        frac = div_s(cod_gain_frac, frac_gcode0);
        tmp = cod_gain_exp - exp_gcode0;
        tmp -= 1;

        Log2((Word32) frac, &exp, &frac, pOverflow);
        exp += tmp;

        /* calculate prediction error (log2, Q10) */
        qua_ener_MR122 = shr_r(frac, 5, pOverflow);
        tmp = exp << 10;
        qua_ener_MR122 += tmp;

        if (qua_ener_MR122 > MAX_QUA_ENER_MR122)
        {
            qua_ener = MAX_QUA_ENER;
            qua_ener_MR122 = MAX_QUA_ENER_MR122;
        }
        else
        {
            /* calculate prediction error (20*log10, Q10) */
            L_tmp = Mpy_32_16(exp, frac, 24660, pOverflow);
            /* 24660 Q12 ~= 6.0206 = 20*log10(2) */
            L_tmp =  L_shl(L_tmp, 13, pOverflow);
            qua_ener = pv_round(L_tmp, pOverflow);

            /* Q12 * Q0 = Q13 -> Q26 -> Q10     */
        }
    }

    /* update MA predictor memory */
    gc_pred_update(pred_st, qua_ener_MR122, qua_ener);


    return;
}

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


/*
------------------------------------------------------------------------------
 FUNCTION NAME: MR475_gain_quant
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    pred_st = pointer to structure of type gc_predState
    sf0_exp_gcode0 = predicted CB gain (exponent) (Word16)
    f0_frac_gcode0 = predicted CB gain (fraction) (Word16)
    sf0_exp_coeff = energy coeff. (exponent part) (Word16)
    sf0_frac_coeff = energy coeff. ((fraction part) (Word16)
    sf0_exp_target_en = exponent of target energy (Word16)
    sf0_frac_target_en = fraction of target energy (Word16)
    sf1_code_nosharp = innovative codebook vector  (Word16)
    sf1_exp_gcode0 = predicted CB gain (exponent) (Word16)
    sf1_frac_gcode0 = predicted CB gain (fraction) (Word16)
    sf1_exp_coeff = energy coeff. (exponent part) (Word16)
    sf1_frac_coeff = energy coeff. (fraction part) (Word16)
    sf1_exp_target_en = exponent of target energy (Word16)
    sf1_frac_target_en = fraction of target energy (Word16)
    gp_limit = pitch gain limit (Word16)
    sf0_gain_pit = pointer to Pitch gain (Word16)
    sf0_gain_cod = pointer to Code gain (Word16)
    sf1_gain_pit = pointer to Pitch gain (Word16)
    sf1_gain_cod = pointer to Code gain (Word16)

 Outputs:
    pred_st points to the updated structure of type gc_predState
    sf0_gain_pit points to Pitch gain
    sf0_gain_cod points to Code gain
    sf1_gain_pit points to Pitch gain
    sf1_gain_cod points to Code gain

 Returns:
    index = index of quantization

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

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

 This module provides quantization of pitch and codebook gains for two
 subframes using the predicted codebook gain.

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

 None.

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

 qgain475.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

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

Word16
MR475_gain_quant(              // o  : index of quantization.
    gc_predState *pred_st,     // i/o: gain predictor state struct

                               // data from subframe 0 (or 2)
    Word16 sf0_exp_gcode0,     // i  : predicted CB gain (exponent),      Q0
    Word16 sf0_frac_gcode0,    // i  : predicted CB gain (fraction),      Q15
    Word16 sf0_exp_coeff[],    // i  : energy coeff. (5), exponent part,  Q0
    Word16 sf0_frac_coeff[],   // i  : energy coeff. (5), fraction part,  Q15
                               //      (frac_coeff and exp_coeff computed in
                               //       calc_filt_energies())
    Word16 sf0_exp_target_en,  // i  : exponent of target energy,         Q0
    Word16 sf0_frac_target_en, // i  : fraction of target energy,         Q15

                               // data from subframe 1 (or 3)
    Word16 sf1_code_nosharp[], // i  : innovative codebook vector (L_SUBFR)
                               //      (whithout pitch sharpening)
    Word16 sf1_exp_gcode0,     // i  : predicted CB gain (exponent),      Q0
    Word16 sf1_frac_gcode0,    // i  : predicted CB gain (fraction),      Q15
    Word16 sf1_exp_coeff[],    // i  : energy coeff. (5), exponent part,  Q0
    Word16 sf1_frac_coeff[],   // i  : energy coeff. (5), fraction part,  Q15
                               //      (frac_coeff and exp_coeff computed in
                               //       calc_filt_energies())
    Word16 sf1_exp_target_en,  // i  : exponent of target energy,         Q0
    Word16 sf1_frac_target_en, // i  : fraction of target energy,         Q15

    Word16 gp_limit,           // i  : pitch gain limit

    Word16 *sf0_gain_pit,      // o  : Pitch gain,                        Q14
    Word16 *sf0_gain_cod,      // o  : Code gain,                         Q1

    Word16 *sf1_gain_pit,      // o  : Pitch gain,                        Q14
    Word16 *sf1_gain_cod       // o  : Code gain,                         Q1
)
{
    const Word16 *p;
    Word16 i, index = 0;
    Word16 tmp;
    Word16 exp;
    Word16 sf0_gcode0, sf1_gcode0;
    Word16 g_pitch, g2_pitch, g_code, g2_code, g_pit_cod;
    Word16 coeff[10], coeff_lo[10], exp_max[10];  // 0..4: sf0; 5..9: sf1
    Word32 L_tmp, dist_min;

     *-------------------------------------------------------------------*
     *  predicted codebook gain                                          *
     *  ~~~~~~~~~~~~~~~~~~~~~~~                                          *
     *  gc0     = 2^exp_gcode0 + 2^frac_gcode0                           *
     *                                                                   *
     *  gcode0 (Q14) = 2^14*2^frac_gcode0 = gc0 * 2^(14-exp_gcode0)      *
     *-------------------------------------------------------------------*

    sf0_gcode0 = extract_l(Pow2(14, sf0_frac_gcode0));
    sf1_gcode0 = extract_l(Pow2(14, sf1_frac_gcode0));

     * For each subframe, the error energy (sum) to be minimized consists
     * of five terms, t[0..4].
     *
     *                      t[0] =    gp^2  * <y1 y1>
     *                      t[1] = -2*gp    * <xn y1>
     *                      t[2] =    gc^2  * <y2 y2>
     *                      t[3] = -2*gc    * <xn y2>
     *                      t[4] =  2*gp*gc * <y1 y2>
     *

    // sf 0
    // determine the scaling exponent for g_code: ec = ec0 - 11
    exp = sub(sf0_exp_gcode0, 11);

    // calculate exp_max[i] = s[i]-1
    exp_max[0] = sub(sf0_exp_coeff[0], 13);
    exp_max[1] = sub(sf0_exp_coeff[1], 14);
    exp_max[2] = add(sf0_exp_coeff[2], add(15, shl(exp, 1)));
    exp_max[3] = add(sf0_exp_coeff[3], exp);
    exp_max[4] = add(sf0_exp_coeff[4], add(1, exp));

    // sf 1
    // determine the scaling exponent for g_code: ec = ec0 - 11
    exp = sub(sf1_exp_gcode0, 11);

    // calculate exp_max[i] = s[i]-1
    exp_max[5] = sub(sf1_exp_coeff[0], 13);
    exp_max[6] = sub(sf1_exp_coeff[1], 14);
    exp_max[7] = add(sf1_exp_coeff[2], add(15, shl(exp, 1)));
    exp_max[8] = add(sf1_exp_coeff[3], exp);
    exp_max[9] = add(sf1_exp_coeff[4], add(1, exp));

     *-------------------------------------------------------------------*
     *  Gain search equalisation:                                        *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~                                        *
     *  The MSE for the two subframes is weighted differently if there   *
     *  is a big difference in the corresponding target energies         *
     *-------------------------------------------------------------------*

    // make the target energy exponents the same by de-normalizing the
    // fraction of the smaller one. This is necessary to be able to compare
    // them

    exp = sf0_exp_target_en - sf1_exp_target_en;
    if (exp > 0)
    {
        sf1_frac_target_en = shr (sf1_frac_target_en, exp);
    }
    else
    {
        sf0_frac_target_en = shl (sf0_frac_target_en, exp);
    }

    // assume no change of exponents
    exp = 0;

    // test for target energy difference; set exp to +1 or -1 to scale
    // up/down coefficients for sf 1

    tmp = shr_r (sf1_frac_target_en, 1);   // tmp = ceil(0.5*en(sf1))
    if (sub (tmp, sf0_frac_target_en) > 0) // tmp > en(sf0)?
    {
        // target_energy(sf1) > 2*target_energy(sf0)
        //   -> scale up MSE(sf0) by 2 by adding 1 to exponents 0..4
        exp = 1;
    }
    else
    {
        tmp = shr (add (sf0_frac_target_en, 3), 2); // tmp=ceil(0.25*en(sf0))
        if (sub (tmp, sf1_frac_target_en) > 0)      // tmp > en(sf1)?
        {
            // target_energy(sf1) < 0.25*target_energy(sf0)
            //   -> scale down MSE(sf0) by 0.5 by subtracting 1 from
            //      coefficients 0..4
            exp = -1;
        }
    }

    for (i = 0; i < 5; i++)
    {
        exp_max[i] = add (exp_max[i], exp);
    }

     *-------------------------------------------------------------------*
     *  Find maximum exponent:                                           *
     *  ~~~~~~~~~~~~~~~~~~~~~~                                           *
     *                                                                   *
     *  For the sum operation, all terms must have the same scaling;     *
     *  that scaling should be low enough to prevent overflow. There-    *
     *  fore, the maximum scale is determined and all coefficients are   *
     *  re-scaled:                                                       *
     *                                                                   *
     *    exp = max(exp_max[i]) + 1;                                     *
     *    e = exp_max[i]-exp;         e <= 0!                            *
     *    c[i] = c[i]*2^e                                                *
     *-------------------------------------------------------------------*

    exp = exp_max[0];
    for (i = 1; i < 10; i++)
    {
        if (sub(exp_max[i], exp) > 0)
        {
            exp = exp_max[i];
        }
    }
    exp = add(exp, 1);      // To avoid overflow

    p = &sf0_frac_coeff[0];
    for (i = 0; i < 5; i++) {
        tmp = sub(exp, exp_max[i]);
        L_tmp = L_deposit_h(*p++);
        L_tmp = L_shr(L_tmp, tmp);
        L_Extract(L_tmp, &coeff[i], &coeff_lo[i]);
    }
    p = &sf1_frac_coeff[0];
    for (; i < 10; i++) {
        tmp = sub(exp, exp_max[i]);
        L_tmp = L_deposit_h(*p++);
        L_tmp = L_shr(L_tmp, tmp);
        L_Extract(L_tmp, &coeff[i], &coeff_lo[i]);
    }

    //-------------------------------------------------------------------*
     *  Codebook search:                                                 *
     *  ~~~~~~~~~~~~~~~~                                                 *
     *                                                                   *
     *  For each pair (g_pitch, g_fac) in the table calculate the        *
     *  terms t[0..4] and sum them up; the result is the mean squared    *
     *  error for the quantized gains from the table. The index for the  *
     *  minimum MSE is stored and finally used to retrieve the quantized *
     *  gains                                                            *
     *-------------------------------------------------------------------

    // start with "infinite" MSE
    dist_min = MAX_32;

    p = &table_gain_MR475[0];

    for (i = 0; i < MR475_VQ_SIZE; i++)
    {
        // subframe 0 (and 2) calculations
        g_pitch = *p++;
        g_code = *p++;

        g_code = mult(g_code, sf0_gcode0);
        g2_pitch = mult(g_pitch, g_pitch);
        g2_code = mult(g_code, g_code);
        g_pit_cod = mult(g_code, g_pitch);

        L_tmp = Mpy_32_16(       coeff[0], coeff_lo[0], g2_pitch);
        L_tmp = Mac_32_16(L_tmp, coeff[1], coeff_lo[1], g_pitch);
        L_tmp = Mac_32_16(L_tmp, coeff[2], coeff_lo[2], g2_code);
        L_tmp = Mac_32_16(L_tmp, coeff[3], coeff_lo[3], g_code);
        L_tmp = Mac_32_16(L_tmp, coeff[4], coeff_lo[4], g_pit_cod);

        tmp = sub (g_pitch, gp_limit);

        // subframe 1 (and 3) calculations
        g_pitch = *p++;
        g_code = *p++;

        if (tmp <= 0 && sub(g_pitch, gp_limit) <= 0)
        {
            g_code = mult(g_code, sf1_gcode0);
            g2_pitch = mult(g_pitch, g_pitch);
            g2_code = mult(g_code, g_code);
            g_pit_cod = mult(g_code, g_pitch);

            L_tmp = Mac_32_16(L_tmp, coeff[5], coeff_lo[5], g2_pitch);
            L_tmp = Mac_32_16(L_tmp, coeff[6], coeff_lo[6], g_pitch);
            L_tmp = Mac_32_16(L_tmp, coeff[7], coeff_lo[7], g2_code);
            L_tmp = Mac_32_16(L_tmp, coeff[8], coeff_lo[8], g_code);
            L_tmp = Mac_32_16(L_tmp, coeff[9], coeff_lo[9], g_pit_cod);

            // store table index if MSE for this index is lower
               than the minimum MSE seen so far
            if (L_sub(L_tmp, dist_min) < (Word32) 0)
            {
                dist_min = L_tmp;
                index = i;
            }
        }
    }

     *------------------------------------------------------------------*
     *  read quantized gains and update MA predictor memories           *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           *
     *------------------------------------------------------------------*

    // for subframe 0, the pre-calculated gcode0/exp_gcode0 are the same
    // as those calculated from the "real" predictor using quantized gains
    tmp = shl(index, 2);
    MR475_quant_store_results(pred_st,
                              &table_gain_MR475[tmp],
                              sf0_gcode0,
                              sf0_exp_gcode0,
                              sf0_gain_pit,
                              sf0_gain_cod);

    // calculate new predicted gain for subframe 1 (this time using
    // the real, quantized gains)
    gc_pred(pred_st, MR475, sf1_code_nosharp,
            &sf1_exp_gcode0, &sf1_frac_gcode0,
            &sf0_exp_gcode0, &sf0_gcode0); // last two args are dummy
    sf1_gcode0 = extract_l(Pow2(14, sf1_frac_gcode0));

    tmp = add (tmp, 2);
    MR475_quant_store_results(pred_st,
                              &table_gain_MR475[tmp],
                              sf1_gcode0,
                              sf1_exp_gcode0,
                              sf1_gain_pit,
                              sf1_gain_cod);

    return index;
}

------------------------------------------------------------------------------
 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 MR475_gain_quant(       /* o  : index of quantization.                 */
    gc_predState *pred_st,     /* i/o: gain predictor state struct            */

    /* data from subframe 0 (or 2) */
    Word16 sf0_exp_gcode0,     /* i  : predicted CB gain (exponent),      Q0  */
    Word16 sf0_frac_gcode0,    /* i  : predicted CB gain (fraction),      Q15 */
    Word16 sf0_exp_coeff[],    /* i  : energy coeff. (5), exponent part,  Q0  */
    Word16 sf0_frac_coeff[],   /* i  : energy coeff. (5), fraction part,  Q15 */
    /*      (frac_coeff and exp_coeff computed in  */
    /*       calc_filt_energies())                 */
    Word16 sf0_exp_target_en,  /* i  : exponent of target energy,         Q0  */
    Word16 sf0_frac_target_en, /* i  : fraction of target energy,         Q15 */

    /* data from subframe 1 (or 3) */
    Word16 sf1_code_nosharp[], /* i  : innovative codebook vector (L_SUBFR)   */
    /*      (whithout pitch sharpening)            */
    Word16 sf1_exp_gcode0,     /* i  : predicted CB gain (exponent),      Q0  */
    Word16 sf1_frac_gcode0,    /* i  : predicted CB gain (fraction),      Q15 */
    Word16 sf1_exp_coeff[],    /* i  : energy coeff. (5), exponent part,  Q0  */
    Word16 sf1_frac_coeff[],   /* i  : energy coeff. (5), fraction part,  Q15 */
    /*      (frac_coeff and exp_coeff computed in  */
    /*       calc_filt_energies())                 */
    Word16 sf1_exp_target_en,  /* i  : exponent of target energy,         Q0  */
    Word16 sf1_frac_target_en, /* i  : fraction of target energy,         Q15 */

    Word16 gp_limit,           /* i  : pitch gain limit                       */

    Word16 *sf0_gain_pit,      /* o  : Pitch gain,                        Q14 */
    Word16 *sf0_gain_cod,      /* o  : Code gain,                         Q1  */

    Word16 *sf1_gain_pit,      /* o  : Pitch gain,                        Q14 */
    Word16 *sf1_gain_cod,      /* o  : Code gain,                         Q1  */
    Flag   *pOverflow          /* o  : overflow indicator                     */
)
{
    const Word16 *p;
    Word16 i;
    Word16 index = 0;
    Word16 tmp;
    Word16 exp;
    Word16 sf0_gcode0;
    Word16 sf1_gcode0;
    Word16 g_pitch;
    Word16 g2_pitch;
    Word16 g_code;
    Word16 g2_code;
    Word16 g_pit_cod;
    Word16 coeff[10];
    Word16 coeff_lo[10];
    Word16 exp_max[10];  /* 0..4: sf0; 5..9: sf1 */
    Word32 L_tmp;
    Word32 dist_min;

    /*-------------------------------------------------------------------*
     *  predicted codebook gain                                          *
     *  ~~~~~~~~~~~~~~~~~~~~~~~                                          *
     *  gc0     = 2^exp_gcode0 + 2^frac_gcode0                           *
     *                                                                   *
     *  gcode0 (Q14) = 2^14*2^frac_gcode0 = gc0 * 2^(14-exp_gcode0)      *
     *-------------------------------------------------------------------*/

    sf0_gcode0 = (Word16)(Pow2(14, sf0_frac_gcode0, pOverflow));
    sf1_gcode0 = (Word16)(Pow2(14, sf1_frac_gcode0, pOverflow));

    /*
     * For each subframe, the error energy (sum) to be minimized consists
     * of five terms, t[0..4].
     *
     *                      t[0] =    gp^2  * <y1 y1>
     *                      t[1] = -2*gp    * <xn y1>
     *                      t[2] =    gc^2  * <y2 y2>
     *                      t[3] = -2*gc    * <xn y2>
     *                      t[4] =  2*gp*gc * <y1 y2>
     *
     */

    /* sf 0 */
    /* determine the scaling exponent for g_code: ec = ec0 - 11 */
    exp = sf0_exp_gcode0 - 11;

    /* calculate exp_max[i] = s[i]-1 */
    exp_max[0] = (sf0_exp_coeff[0] - 13);
    exp_max[1] = (sf0_exp_coeff[1] - 14);
    exp_max[2] = (sf0_exp_coeff[2] + (15 + (exp << 1)));
    exp_max[3] = (sf0_exp_coeff[3] + exp);
    exp_max[4] = (sf0_exp_coeff[4] + (1 + exp));

    /* sf 1 */
    /* determine the scaling exponent for g_code: ec = ec0 - 11 */
    exp = sf1_exp_gcode0 - 11;

    /* calculate exp_max[i] = s[i]-1 */
    exp_max[5] = (sf1_exp_coeff[0] - 13);
    exp_max[6] = (sf1_exp_coeff[1] - 14);
    exp_max[7] = (sf1_exp_coeff[2] + (15 + (exp << 1)));
    exp_max[8] = (sf1_exp_coeff[3] + exp);
    exp_max[9] = (sf1_exp_coeff[4] + (1 + exp));

    /*-------------------------------------------------------------------*
     *  Gain search equalisation:                                        *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~                                        *
     *  The MSE for the two subframes is weighted differently if there   *
     *  is a big difference in the corresponding target energies         *
     *-------------------------------------------------------------------*/

    /* make the target energy exponents the same by de-normalizing the
       fraction of the smaller one. This is necessary to be able to compare
       them
     */
    exp = sf0_exp_target_en - sf1_exp_target_en;
    if (exp > 0)
    {
        sf1_frac_target_en >>= exp;
    }
    else
    {
        sf0_frac_target_en >>= (-exp);
    }

    /* assume no change of exponents */
    exp = 0;

    /* test for target energy difference; set exp to +1 or -1 to scale
     * up/down coefficients for sf 1
     */
    tmp = shr_r(sf1_frac_target_en, 1, pOverflow);  /* tmp = ceil(0.5*en(sf1)) */

    if (tmp > sf0_frac_target_en)          /* tmp > en(sf0)? */
    {
        /*
         * target_energy(sf1) > 2*target_energy(sf0)
         *   -> scale up MSE(sf0) by 2 by adding 1 to exponents 0..4
         */
        exp = 1;
    }
    else
    {
        tmp = ((sf0_frac_target_en + 3) >> 2); /* tmp=ceil(0.25*en(sf0)) */

        if (tmp > sf1_frac_target_en)      /* tmp > en(sf1)? */
        {
            /*
             * target_energy(sf1) < 0.25*target_energy(sf0)
             *   -> scale down MSE(sf0) by 0.5 by subtracting 1 from
             *      coefficients 0..4
             */
            exp = -1;
        }
    }

    for (i = 0; i < 5; i++)
    {
        exp_max[i] += exp;
    }

    /*-------------------------------------------------------------------*
     *  Find maximum exponent:                                           *
     *  ~~~~~~~~~~~~~~~~~~~~~~                                           *
     *                                                                   *
     *  For the sum operation, all terms must have the same scaling;     *
     *  that scaling should be low enough to prevent overflow. There-    *
     *  fore, the maximum scale is determined and all coefficients are   *
     *  re-scaled:                                                       *
     *                                                                   *
     *    exp = max(exp_max[i]) + 1;                                     *
     *    e = exp_max[i]-exp;         e <= 0!                            *
     *    c[i] = c[i]*2^e                                                *
     *-------------------------------------------------------------------*/

    exp = exp_max[0];
    for (i = 9; i > 0; i--)
    {
        if (exp_max[i] > exp)
        {
            exp = exp_max[i];
        }
    }
    exp++;      /* To avoid overflow */

    p = &sf0_frac_coeff[0];
    for (i = 0; i < 5; i++)
    {
        tmp = (exp - exp_max[i]);
        L_tmp = ((Word32)(*p++) << 16);
        L_tmp = L_shr(L_tmp, tmp, pOverflow);
        coeff[i] = (Word16)(L_tmp >> 16);
        coeff_lo[i] = (Word16)((L_tmp >> 1) - ((L_tmp >> 16) << 15));
    }
    p = &sf1_frac_coeff[0];
    for (; i < 10; i++)
    {
        tmp = exp - exp_max[i];
        L_tmp = ((Word32)(*p++) << 16);
        L_tmp = L_shr(L_tmp, tmp, pOverflow);
        coeff[i] = (Word16)(L_tmp >> 16);
        coeff_lo[i] = (Word16)((L_tmp >> 1) - ((L_tmp >> 16) << 15));
    }


    /*-------------------------------------------------------------------*
     *  Codebook search:                                                 *
     *  ~~~~~~~~~~~~~~~~                                                 *
     *                                                                   *
     *  For each pair (g_pitch, g_fac) in the table calculate the        *
     *  terms t[0..4] and sum them up; the result is the mean squared    *
     *  error for the quantized gains from the table. The index for the  *
     *  minimum MSE is stored and finally used to retrieve the quantized *
     *  gains                                                            *
     *-------------------------------------------------------------------*/

    /* start with "infinite" MSE */
    dist_min = MAX_32;

    p = &table_gain_MR475[0];

    for (i = 0; i < MR475_VQ_SIZE; i++)
    {
        /* subframe 0 (and 2) calculations */
        g_pitch = *p++;
        g_code = *p++;

        /* Need to be there OKA */
        g_code    = (Word16)(((Word32) g_code * sf0_gcode0) >> 15);
        g2_pitch  = (Word16)(((Word32) g_pitch * g_pitch) >> 15);
        g2_code   = (Word16)(((Word32) g_code * g_code) >> 15);
        g_pit_cod = (Word16)(((Word32) g_code * g_pitch) >> 15);


        L_tmp = Mpy_32_16(coeff[0], coeff_lo[0], g2_pitch, pOverflow) +
                Mpy_32_16(coeff[1], coeff_lo[1], g_pitch, pOverflow) +
                Mpy_32_16(coeff[2], coeff_lo[2], g2_code, pOverflow) +
                Mpy_32_16(coeff[3], coeff_lo[3], g_code, pOverflow) +
                Mpy_32_16(coeff[4], coeff_lo[4], g_pit_cod, pOverflow);

        tmp = (g_pitch - gp_limit);

        /* subframe 1 (and 3) calculations */
        g_pitch = *p++;
        g_code = *p++;

        if ((tmp <= 0) && (g_pitch <= gp_limit))
        {
            g_code = (Word16)(((Word32) g_code * sf1_gcode0) >> 15);
            g2_pitch  = (Word16)(((Word32) g_pitch * g_pitch) >> 15);
            g2_code   = (Word16)(((Word32) g_code * g_code) >> 15);
            g_pit_cod = (Word16)(((Word32) g_code * g_pitch) >> 15);

            L_tmp += (Mpy_32_16(coeff[5], coeff_lo[5], g2_pitch, pOverflow) +
                      Mpy_32_16(coeff[6], coeff_lo[6], g_pitch, pOverflow) +
                      Mpy_32_16(coeff[7], coeff_lo[7], g2_code, pOverflow) +
                      Mpy_32_16(coeff[8], coeff_lo[8], g_code, pOverflow) +
                      Mpy_32_16(coeff[9], coeff_lo[9], g_pit_cod, pOverflow));

            /* store table index if MSE for this index is lower
               than the minimum MSE seen so far */
            if (L_tmp < dist_min)
            {
                dist_min = L_tmp;
                index = i;
            }
        }
    }

    /*------------------------------------------------------------------*
     *  read quantized gains and update MA predictor memories           *
     *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           *
     *------------------------------------------------------------------*/

    /* for subframe 0, the pre-calculated gcode0/exp_gcode0 are the same
       as those calculated from the "real" predictor using quantized gains */
    tmp = index << 2;
    MR475_quant_store_results(pred_st,
                              &table_gain_MR475[tmp],
                              sf0_gcode0,
                              sf0_exp_gcode0,
                              sf0_gain_pit,
                              sf0_gain_cod,
                              pOverflow);

    /* calculate new predicted gain for subframe 1 (this time using
       the real, quantized gains)                                   */
    gc_pred(pred_st, MR475, sf1_code_nosharp,
            &sf1_exp_gcode0, &sf1_frac_gcode0,
            &sf0_exp_gcode0, &sf0_gcode0, /* dummy args */
            pOverflow);

    sf1_gcode0 = (Word16)(Pow2(14, sf1_frac_gcode0, pOverflow));

    tmp += 2;
    MR475_quant_store_results(
        pred_st,
        &table_gain_MR475[tmp],
        sf1_gcode0,
        sf1_exp_gcode0,
        sf1_gain_pit,
        sf1_gain_cod,
        pOverflow);

    return(index);
}