g729ev_g729_qua_gain.c

最新的ITU-T的宽带语音编解码标准G.729.1,是对原先的G.729的最好的调整.码流输出速率可以进行自适应调整.满足未来通信要求.希望对大家有所帮助.

/* ITU-T G.729EV Optimization/Characterization Candidate                         */
/* Version:       1.0.a                                                          */
/* Revision Date: June 28, 2006                                                  */

/*
   ITU-T G.729EV Optimization/Characterization Candidate    ANSI-C Source Code
   Copyright (c) 2006 
   France Telecom, Matsushita Electric, Mindspeed, Siemens AG, ETRI, VoiceAge Corp.
   All rights reserved
*/

#include "stl.h"
#include "G729EV_MAIN_OPER_32B.h"

#include "G729EV_G729_ld8k.h"
#include "G729EV_G729_TAB_ld8k.h"


static void G729EV_G729_Gbk_presel(Word16 best_gain[],  /* (i) [0] Q9 : unquantized pitch gain     */
                                                        /* (i) [1] Q2 : unquantized code gain      */
                                   Word16 * cand1,      /* (o)    : index of best 1st stage vector */
                                   Word16 * cand2,      /* (o)    : index of best 2nd stage vector */
                                   Word16 gcode0        /* (i) Q4 : presearch for gain codebook    */
    );


/*---------------------------------------------------------------------------*
 * Function  G729EV_G729_Qua_gain                                            *
 * ~~~~~~~~~~~~~~~~~~                                                        *
 * Inputs:                                                                   *
 *   code[]     :Innovative codebook.                                        *
 *   g_coeff[]  :Correlations compute for pitch.                             *
 *   L_subfr    :Subframe length.                                            *
 *                                                                           *
 * Outputs:                                                                  *
 *   gain_pit   :Quantized pitch gain.                                       *
 *   gain_cod   :Quantized code gain.                                        *
 *                                                                           *
 * Return:                                                                   *
 *   Index of quantization.                                                  *
 *                                                                           *
 *--------------------------------------------------------------------------*/
Word16 G729EV_G729_Qua_gain(Word16 code[],       /* (i) Q13 :Innovative vector.             */
                            Word16 g_coeff[],    /* (i)     :Correlations <xn y1> -2<y1 y1> */
                            /*                                <y2,y2>, -2<xn,y2>, 2<y1,y2> */
                            Word16 exp_coeff[], /* (i)     :Q-Format g_coeff[]             */
                            Word16 L_subfr,     /* (i)     :Subframe length.               */
                            Word16 * gain_pit,  /* (o) Q14 :Pitch gain.                    */
                            Word16 * gain_cod,  /* (o) Q1  :Code gain.                     */
                            Word16 tameflag,    /* (i)     : set to 1 if taming is needed  */
                            Word16 past_qua_en[])
{
  Word32    L_tmp, L_dist_min, L_temp, L_tmp1, L_tmp2, L_acc, L_accb;
  Word32    L_gbk12;

  Word16    coeff[5], coeff_lsf[5];
  Word16    exp_min[5];
  Word16    best_gain[2];

  Word16    i, j, index1, index2;
  Word16    cand1, cand2;
  Word16    exp, gcode0, exp_gcode0, gcode0_org, e_min;
  Word16    nume, denom, inv_denom;
  Word16    exp1, exp2, exp_nume, exp_denom, exp_inv_denom, sft, tmp;
  Word16    g_pitch, g2_pitch, g_code, g2_code, g_pit_cod;


  /*---------------------------------------------------*
   *-  energy due to innovation                       -*
   *-  predicted energy                               -*
   *-  predicted codebook gain => gcode0[exp_gcode0]  -*
   *---------------------------------------------------*/

  G729EV_G729_Gain_predict(past_qua_en, code, L_subfr, &gcode0, &exp_gcode0);

  /*-----------------------------------------------------------------*
   *  pre-selection                                                  *
   *-----------------------------------------------------------------*/
  /*-----------------------------------------------------------------*
   *  calculate best gain                                            *
   *                                                                 *
   *  tmp = -1./(4.*coeff[0]*coeff[2]-coeff[4]*coeff[4]) ;           *
   *  best_gain[0] = (2.*coeff[2]*coeff[1]-coeff[3]*coeff[4])*tmp ;  *
   *  best_gain[1] = (2.*coeff[0]*coeff[3]-coeff[1]*coeff[4])*tmp ;  *
   *  G729EV_G729_gbk_presel(best_gain,&cand1,&cand2,gcode0) ;                   *
   *                                                                 *
   *-----------------------------------------------------------------*/

  /*-----------------------------------------------------------------*
   *  tmp = -1./(4.*coeff[0]*coeff[2]-coeff[4]*coeff[4]) ;           *
   *-----------------------------------------------------------------*/
  L_tmp1 = L_mult(g_coeff[0], g_coeff[2]);
  exp1 = add(add(exp_coeff[0], exp_coeff[2]), 1 - 2);
  L_tmp2 = L_mult(g_coeff[4], g_coeff[4]);
  exp2 = add(add(exp_coeff[4], exp_coeff[4]), 1);

  IF(sub(exp1, exp2) > 0)
  {
    L_tmp = L_sub(L_shr(L_tmp1, sub(exp1, exp2)), L_tmp2);
    exp = exp2;
  }
  ELSE
  {
    L_tmp = L_sub(L_tmp1, L_shr(L_tmp2, sub(exp2, exp1)));
    exp = exp1;
  }
#if (WMOPS)
  move16();
#endif

  sft = norm_l(L_tmp);
  denom = extract_h(L_shl(L_tmp, sft));
  exp_denom = sub(add(exp, sft), 16);

  inv_denom = div_s(16384, denom);
  inv_denom = negate(inv_denom);
  exp_inv_denom = sub(14 + 15, exp_denom);

  /*-----------------------------------------------------------------*
   *  best_gain[0] = (2.*coeff[2]*coeff[1]-coeff[3]*coeff[4])*tmp ;  *
   *-----------------------------------------------------------------*/
  L_tmp1 = L_mult(g_coeff[2], g_coeff[1]);
  exp1 = add(exp_coeff[2], exp_coeff[1]);
  L_tmp2 = L_mult(g_coeff[3], g_coeff[4]);
  exp2 = add(add(exp_coeff[3], exp_coeff[4]), 1);

  IF(sub(exp1, exp2) > 0)
  {
    L_tmp = L_sub(L_shr(L_tmp1, add(sub(exp1, exp2), 1)), L_shr(L_tmp2, 1));
    exp = sub(exp2, 1);
  }
  ELSE
  {
    L_tmp = L_sub(L_shr(L_tmp1, 1), L_shr(L_tmp2, add(sub(exp2, exp1), 1)));
    exp = sub(exp1, 1);
  }
  sft = norm_l(L_tmp);
  nume = extract_h(L_shl(L_tmp, sft));
  exp_nume = sub(add(exp, sft), 16);

  sft = sub(add(exp_nume, exp_inv_denom), (9 + 16 - 1));
  L_acc = L_shr(L_mult(nume, inv_denom), sft);
  best_gain[0] = extract_h(L_acc);                /*-- best_gain[0]:Q9 --*/
#ifdef WMOPS
  move16();
#endif


  IF(sub(tameflag, 1) == 0)
  {
    if (sub(best_gain[0], G729EV_G729_GPCLIP2) > 0)
    {
#if (WMOPS)
      move16();
#endif
      best_gain[0] = G729EV_G729_GPCLIP2;
    }
  }

  /*-----------------------------------------------------------------*
   *  best_gain[1] = (2.*coeff[0]*coeff[3]-coeff[1]*coeff[4])*tmp ;  *
   *-----------------------------------------------------------------*/
  L_tmp1 = L_mult(g_coeff[0], g_coeff[3]);
  exp1 = add(exp_coeff[0], exp_coeff[3]);
  L_tmp2 = L_mult(g_coeff[1], g_coeff[4]);
  exp2 = add(add(exp_coeff[1], exp_coeff[4]), 1);

  IF(sub(exp1, exp2) > 0)
  {
    L_tmp = L_sub(L_shr(L_tmp1, add(sub(exp1, exp2), 1)), L_shr(L_tmp2, 1));
    exp = sub(exp2, 1);
  }
  ELSE
  {
    L_tmp = L_sub(L_shr(L_tmp1, 1), L_shr(L_tmp2, add(sub(exp2, exp1), 1)));
    exp = sub(exp1, 1);
  }
  sft = norm_l(L_tmp);
  nume = extract_h(L_shl(L_tmp, sft));
  exp_nume = sub(add(exp, sft), 16);

  sft = sub(add(exp_nume, exp_inv_denom), (2 + 16 - 1));
  L_acc = L_shr(L_mult(nume, inv_denom), sft);
  best_gain[1] = extract_h(L_acc);                /*-- best_gain[1]:Q2 --*/
#ifdef WMOPS
  move16();
#endif

   /*--- Change Q-format of gcode0 ( Q[exp_gcode0] -> Q4 ) ---*/
  IF(sub(exp_gcode0, 4) >= 0)
  {
    gcode0_org = shr(gcode0, sub(exp_gcode0, 4));
  }
  ELSE
  {
    L_acc = L_deposit_l(gcode0);
    L_acc = L_shl(L_acc, sub((4 + 16), exp_gcode0));
    gcode0_org = extract_h(L_acc);                  /*-- gcode0_org:Q4 --*/
  }

  /*----------------------------------------------*
   *   - presearch for gain codebook -            *
   *----------------------------------------------*/

  G729EV_G729_Gbk_presel(best_gain, &cand1, &cand2, gcode0_org);

/*---------------------------------------------------------------------------*
 *                                                                           *
 * Find the best quantizer.                                                  *
 *                                                                           *
 *  dist_min = MAX_32;                                                       *
 *  FOR( i=0 ; i<NCAN1 ; i++ ){                                             *
 *    FOR( j=0 ; j<NCAN2 ; j++ ){                                           *
 *      g_pitch = gbk1[cand1+i][0] + gbk2[cand2+j][0];                       *

 *      g_code = gcode0 * (gbk1[cand1+i][1] + gbk2[cand2+j][1]);             *
 *      dist = g_pitch*g_pitch * coeff[0]                                    *
 *           + g_pitch         * coeff[1]                                    *
 *           + g_code*g_code   * coeff[2]                                    *
 *           + g_code          * coeff[3]                                    *
 *           + g_pitch*g_code  * coeff[4] ;                                  *
 *                                                                           *
 *      if (dist < dist_min){                                                *
 *        dist_min = dist;                                                   *
 *        indice1 = cand1 + i ;                                              *
 *        indice2 = cand2 + j ;                                              *
 *      }                                                                    *
 *    }                                                                      *
 *  }                                                                        *
 *                                                                           *
 * g_pitch         = Q13                                                     *
 * g_pitch*g_pitch = Q11:(13+13+1-16)                                        *
 * g_code          = Q[exp_gcode0-3]:(exp_gcode0+(13-1)+1-16)                *
 * g_code*g_code   = Q[2*exp_gcode0-21]:(exp_gcode0-3+exp_gcode0-3+1-16)     *
 * g_pitch*g_code  = Q[exp_gcode0-5]:(13+exp_gcode0-3+1-16)                  *
 *                                                                           *
 * term 0: g_pitch*g_pitch*coeff[0] ;exp_min0 = 13             +exp_coeff[0] *
 * term 1: g_pitch        *coeff[1] ;exp_min1 = 14             +exp_coeff[1] *
 * term 2: g_code*g_code  *coeff[2] ;exp_min2 = 2*exp_gcode0-21+exp_coeff[2] *
 * term 3: g_code         *coeff[3] ;exp_min3 = exp_gcode0  - 3+exp_coeff[3] *
 * term 4: g_pitch*g_code *coeff[4] ;exp_min4 = exp_gcode0  - 4+exp_coeff[4] *
 *                                                                           *
 *---------------------------------------------------------------------------*/

#if (WMOPS)
  move16();
  move16();
  move16();
  move16();
  move16();
#endif
  exp_min[0] = add(exp_coeff[0], 13);
  exp_min[1] = add(exp_coeff[1], 14);
  exp_min[2] = add(exp_coeff[2], sub(shl(exp_gcode0, 1), 21));
  exp_min[3] = add(exp_coeff[3], sub(exp_gcode0, 3));
  exp_min[4] = add(exp_coeff[4], sub(exp_gcode0, 4));

  e_min = exp_min[0];
#if (WMOPS)
  move16();
#endif

  FOR(i = 1; i < 5; i++)
  {
    if (sub(exp_min[i], e_min) < 0)
    {
#if (WMOPS)
      move16();
#endif
      e_min = exp_min[i];
    }
  }

  /* align coeff[] and save in special 32 bit double precision */