示例#1
0
  public void dec_gain(
      int index, /* input : quantizer index              */
      float code[], /* input : fixed code book vector       */
      int l_subfr, /* input : subframe size                */
      int bfi, /* input : bad frame indicator good = 0 */
      FloatPointer gain_pit, /* output: quantized acb gain           */
      FloatPointer gain_code /* output: quantized fcb gain           */) {

    int index1, index2;
    float g_code;
    FloatPointer gcode0 = new FloatPointer();

    /*----------------- Test erasure ---------------*/
    if (bfi != 0) {
      gain_pit.value *= (float) 0.9;
      if (gain_pit.value > (float) 0.9) gain_pit.value = (float) 0.9;
      gain_code.value *= (float) 0.98;

      /*----------------------------------------------*
       * update table of past quantized energies      *
       *                              (frame erasure) *
       *----------------------------------------------*/
      GainPred.gain_update_erasure(past_qua_en);

      return;
    }

    /*-------------- Decode pitch gain ---------------*/

    index1 = TabLD8k.imap1[index / LD8KConstants.NCODE2];
    index2 = TabLD8k.imap2[index % LD8KConstants.NCODE2];
    gain_pit.value = TabLD8k.gbk1[index1][0] + TabLD8k.gbk2[index2][0];

    /*-------------- Decode codebook gain ---------------*/

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

    GainPred.gain_predict(past_qua_en, code, l_subfr, gcode0);

    /*-----------------------------------------------------------------*
     * *gain_code = (gbk1[indice1][1]+gbk2[indice2][1]) * gcode0;      *
     *-----------------------------------------------------------------*/

    g_code = TabLD8k.gbk1[index1][1] + TabLD8k.gbk2[index2][1];
    gain_code.value = g_code * gcode0.value;

    /*----------------------------------------------*
     * update table of past quantized energies      *
     *----------------------------------------------*/

    GainPred.gain_update(past_qua_en, g_code);

    return;
  }
示例#2
0
  /*----------------------------------------------------------------------------
   * qua_gain - Quantization of pitch and codebook gains
   *----------------------------------------------------------------------------
   */
  int qua_gain(
      /* output: quantizer index                   */
      float code[], /* input : fixed codebook vector             */
      float[] g_coeff, /* input : correlation factors               */
      int l_subfr, /* input : fcb vector length                 */
      FloatPointer gain_pit, /* output: quantized acb gain                */
      FloatPointer gain_code, /* output: quantized fcb gain                */
      int tameflag /* input : flag set to 1 if taming is needed */) {
    /*
     * MA prediction is performed on the innovation energy (in dB with mean      *
     * removed).                                                                 *
     * An initial predicted gain, g_0, is first determined and the correction    *
     * factor     alpha = gain / g_0    is quantized.                            *
     * The pitch gain and the correction factor are vector quantized and the     *
     * mean-squared weighted error criterion is used in the quantizer search.    *
     *   CS Codebook , fast pre-selection version                                *
     */

    int i, j, index1 = 0, index2 = 0;
    IntegerPointer cand1 = new IntegerPointer(0), cand2 = new IntegerPointer(0);
    FloatPointer gcode0 = new FloatPointer((float) 0);
    float dist = 0;
    float dist_min = 0;
    float g_pitch = 0;
    float g_code = 0;
    float best_gain[] = new float[2], tmp;

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

    GainPred.gain_predict(past_qua_en, code, l_subfr, gcode0);

    /*-- pre-selection --*/
    tmp = (float) -1. / ((float) 4. * g_coeff[0] * g_coeff[2] - g_coeff[4] * g_coeff[4]);
    best_gain[0] = ((float) 2. * g_coeff[2] * g_coeff[1] - g_coeff[3] * g_coeff[4]) * tmp;
    best_gain[1] = ((float) 2. * g_coeff[0] * g_coeff[3] - g_coeff[1] * g_coeff[4]) * tmp;

    if (tameflag == 1) {
      if (best_gain[0] > LD8KConstants.GPCLIP2) best_gain[0] = LD8KConstants.GPCLIP2;
    }
    /*----------------------------------------------*
     *   - presearch for gain codebook -            *
     *----------------------------------------------*/

    gbk_presel(best_gain, cand1, cand2, gcode0.value);

    /*-- selection --*/
    dist_min = LD8KConstants.FLT_MAX_G729;
    if (tameflag == 1) {
      for (i = 0; i < LD8KConstants.NCAN1; i++) {
        for (j = 0; j < LD8KConstants.NCAN2; j++) {
          g_pitch = TabLD8k.gbk1[cand1.value + i][0] + TabLD8k.gbk2[cand2.value + j][0];
          if (g_pitch < LD8KConstants.GP0999) {
            g_code =
                gcode0.value
                    * (TabLD8k.gbk1[cand1.value + i][1] + TabLD8k.gbk2[cand2.value + j][1]);
            dist =
                g_pitch * g_pitch * g_coeff[0]
                    + g_pitch * g_coeff[1]
                    + g_code * g_code * g_coeff[2]
                    + g_code * g_coeff[3]
                    + g_pitch * g_code * g_coeff[4];
            if (dist < dist_min) {
              dist_min = dist;
              index1 = cand1.value + i;
              index2 = cand2.value + j;
            }
          }
        }
      }
    } else {
      for (i = 0; i < LD8KConstants.NCAN1; i++) {
        for (j = 0; j < LD8KConstants.NCAN2; j++) {
          g_pitch = TabLD8k.gbk1[cand1.value + i][0] + TabLD8k.gbk2[cand2.value + j][0];
          g_code =
              gcode0.value * (TabLD8k.gbk1[cand1.value + i][1] + TabLD8k.gbk2[cand2.value + j][1]);
          dist =
              g_pitch * g_pitch * g_coeff[0]
                  + g_pitch * g_coeff[1]
                  + g_code * g_code * g_coeff[2]
                  + g_code * g_coeff[3]
                  + g_pitch * g_code * g_coeff[4];
          if (dist < dist_min) {
            dist_min = dist;
            index1 = cand1.value + i;
            index2 = cand2.value + j;
          }
        }
      }
    }
    gain_pit.value = TabLD8k.gbk1[index1][0] + TabLD8k.gbk2[index2][0];
    g_code = TabLD8k.gbk1[index1][1] + TabLD8k.gbk2[index2][1];
    gain_code.value = g_code * gcode0.value;
    /*----------------------------------------------*
     * update table of past quantized energies      *
     *----------------------------------------------*/
    GainPred.gain_update(past_qua_en, g_code);

    return (TabLD8k.map1[index1] * LD8KConstants.NCODE2 + TabLD8k.map2[index2]);
  }