Exemple #1
0
  /** Also calculates the number of bits necessary to code the scalefactors. */
  public boolean scale_bitcount(final GrInfo cod_info) {
    int k, sfb, max_slen1 = 0, max_slen2 = 0;

    /* maximum values */
    int[] tab;
    final int[] scalefac = cod_info.scalefac;

    assert (all_scalefactors_not_negative(scalefac, cod_info.sfbmax));

    if (cod_info.block_type == Encoder.SHORT_TYPE) {
      tab = scale_short;
      if (cod_info.mixed_block_flag != 0) tab = scale_mixed;
    } else {
      /* block_type == 1,2,or 3 */
      tab = scale_long;
      if (0 == cod_info.preflag) {
        for (sfb = 11; sfb < Encoder.SBPSY_l; sfb++) if (scalefac[sfb] < qupvt.pretab[sfb]) break;

        if (sfb == Encoder.SBPSY_l) {
          cod_info.preflag = 1;
          for (sfb = 11; sfb < Encoder.SBPSY_l; sfb++) scalefac[sfb] -= qupvt.pretab[sfb];
        }
      }
    }

    for (sfb = 0; sfb < cod_info.sfbdivide; sfb++)
      if (max_slen1 < scalefac[sfb]) max_slen1 = scalefac[sfb];

    for (; sfb < cod_info.sfbmax; sfb++) if (max_slen2 < scalefac[sfb]) max_slen2 = scalefac[sfb];

    /*
     * from Takehiro TOMINAGA <*****@*****.**> 10/99 loop over *all*
     * posible values of scalefac_compress to find the one which uses the
     * smallest number of bits. ISO would stop at first valid index
     */
    cod_info.part2_length = QuantizePVT.LARGE_BITS;
    for (k = 0; k < 16; k++) {
      if (max_slen1 < slen1_n[k] && max_slen2 < slen2_n[k] && cod_info.part2_length > tab[k]) {
        cod_info.part2_length = tab[k];
        cod_info.scalefac_compress = k;
      }
    }
    return cod_info.part2_length == QuantizePVT.LARGE_BITS;
  }
Exemple #2
0
  private void scfsi_calc(int ch, final IIISideInfo l3_side) {
    int sfb;
    final GrInfo gi = l3_side.tt[1][ch];
    final GrInfo g0 = l3_side.tt[0][ch];

    for (int i = 0; i < Tables.scfsi_band.length - 1; i++) {
      for (sfb = Tables.scfsi_band[i]; sfb < Tables.scfsi_band[i + 1]; sfb++) {
        if (g0.scalefac[sfb] != gi.scalefac[sfb] && gi.scalefac[sfb] >= 0) break;
      }
      if (sfb == Tables.scfsi_band[i + 1]) {
        for (sfb = Tables.scfsi_band[i]; sfb < Tables.scfsi_band[i + 1]; sfb++) {
          gi.scalefac[sfb] = -1;
        }
        l3_side.scfsi[ch][i] = 1;
      }
    }

    int s1 = 0;
    int c1 = 0;
    for (sfb = 0; sfb < 11; sfb++) {
      if (gi.scalefac[sfb] == -1) continue;
      c1++;
      if (s1 < gi.scalefac[sfb]) s1 = gi.scalefac[sfb];
    }

    int s2 = 0;
    int c2 = 0;
    for (; sfb < Encoder.SBPSY_l; sfb++) {
      if (gi.scalefac[sfb] == -1) continue;
      c2++;
      if (s2 < gi.scalefac[sfb]) s2 = gi.scalefac[sfb];
    }

    for (int i = 0; i < 16; i++) {
      if (s1 < slen1_n[i] && s2 < slen2_n[i]) {
        final int c = slen1_tab[i] * c1 + slen2_tab[i] * c2;
        if (gi.part2_length > c) {
          gi.part2_length = c;
          gi.scalefac_compress = i;
        }
      }
    }
  }
Exemple #3
0
  /**
   * Also counts the number of bits to encode the scalefacs but for MPEG 2 Lower sampling
   * frequencies (24, 22.05 and 16 kHz.)
   *
   * <p>This is reverse-engineered from section 2.4.3.2 of the MPEG2 IS, "Audio Decoding Layer III"
   */
  public boolean scale_bitcount_lsf(final LameInternalFlags gfc, final GrInfo cod_info) {
    int table_number, row_in_table, partition, nr_sfb, window;
    boolean over;
    int i, sfb, max_sfac[] = new int[4];
    final int[] partition_table;
    final int[] scalefac = cod_info.scalefac;

    /*
     * Set partition table. Note that should try to use table one, but do
     * not yet...
     */
    if (cod_info.preflag != 0) table_number = 2;
    else table_number = 0;

    for (i = 0; i < 4; i++) max_sfac[i] = 0;

    if (cod_info.block_type == Encoder.SHORT_TYPE) {
      row_in_table = 1;
      partition_table = qupvt.nr_of_sfb_block[table_number][row_in_table];
      for (sfb = 0, partition = 0; partition < 4; partition++) {
        nr_sfb = partition_table[partition] / 3;
        for (i = 0; i < nr_sfb; i++, sfb++)
          for (window = 0; window < 3; window++)
            if (scalefac[sfb * 3 + window] > max_sfac[partition])
              max_sfac[partition] = scalefac[sfb * 3 + window];
      }
    } else {
      row_in_table = 0;
      partition_table = qupvt.nr_of_sfb_block[table_number][row_in_table];
      for (sfb = 0, partition = 0; partition < 4; partition++) {
        nr_sfb = partition_table[partition];
        for (i = 0; i < nr_sfb; i++, sfb++)
          if (scalefac[sfb] > max_sfac[partition]) max_sfac[partition] = scalefac[sfb];
      }
    }

    for (over = false, partition = 0; partition < 4; partition++) {
      if (max_sfac[partition] > max_range_sfac_tab[table_number][partition]) over = true;
    }
    if (!over) {

      int slen1, slen2, slen3, slen4;

      cod_info.sfb_partition_table = qupvt.nr_of_sfb_block[table_number][row_in_table];
      for (partition = 0; partition < 4; partition++)
        cod_info.slen[partition] = log2tab[max_sfac[partition]];

      /* set scalefac_compress */
      slen1 = cod_info.slen[0];
      slen2 = cod_info.slen[1];
      slen3 = cod_info.slen[2];
      slen4 = cod_info.slen[3];

      switch (table_number) {
        case 0:
          cod_info.scalefac_compress = (((slen1 * 5) + slen2) << 4) + (slen3 << 2) + slen4;
          break;

        case 1:
          cod_info.scalefac_compress = 400 + (((slen1 * 5) + slen2) << 2) + slen3;
          break;

        case 2:
          cod_info.scalefac_compress = 500 + (slen1 * 3) + slen2;
          break;

        default:
          System.err.printf("intensity stereo not implemented yet\n");
          break;
      }
    }
    if (!over) {
      assert (cod_info.sfb_partition_table != null);
      cod_info.part2_length = 0;
      for (partition = 0; partition < 4; partition++)
        cod_info.part2_length += cod_info.slen[partition] * cod_info.sfb_partition_table[partition];
    }
    return over;
  }