Ejemplo n.º 1
0
  private void vorbis_encode_global_psych_setup(float s, vorbis_info_psy_global[] in, float[] x) {

    int i;
    int is = new Float(s).intValue();
    float ds = s - is;
    codec_setup_info ci = vi.codec_setup;

    // memcpy(g,in+(int)x[is],sizeof(*g));
    ci.psy_g_param = new vorbis_info_psy_global(in[new Float(x[is]).intValue()]);
    vorbis_info_psy_global g = ci.psy_g_param;

    ds = x[is] * (1.0f - ds) + x[is + 1] * ds;

    is = new Float(ds).intValue();
    ds -= is;
    if (ds == 0 && is > 0) {
      is--;
      ds = 1.0f;
    }

    // interpolate the trigger threshholds
    for (i = 0; i < 4; i++) {
      g.preecho_thresh[i] =
          new Double(in[is].preecho_thresh[i] * (1. - ds) + in[is + 1].preecho_thresh[i] * ds)
              .floatValue();
      g.postecho_thresh[i] =
          new Double(in[is].postecho_thresh[i] * (1. - ds) + in[is + 1].postecho_thresh[i] * ds)
              .floatValue();
    }
    g.ampmax_att_per_sec = ci.hi.amplitude_track_dBpersec;
  }
Ejemplo n.º 2
0
  // we assume two maps in this encoder
  private void vorbis_encode_map_n_res_setup(float s, vorbis_mapping_template[] maps) {

    codec_setup_info ci = vi.codec_setup;
    int i, j;
    int is = new Float(s).intValue();
    int modes = 2;
    vorbis_info_mapping0[] map = maps[is].map;
    vorbis_info_mode[] mode = {
      new vorbis_info_mode(0, 0, 0, 0), new vorbis_info_mode(1, 0, 0, 1)
    }; // _mode_template
    vorbis_residue_template[] res = maps[is].res;

    if (ci.blocksizes[0] == ci.blocksizes[1]) modes = 1;

    for (i = 0; i < modes; i++) {

      // ci.map_param[i] = _ogg_calloc(1,sizeof(*map));
      // ci.mode_param[i] = _ogg_calloc(1,sizeof(*mode));
      // memcpy(ci.mode_param[i],mode+i,sizeof(*_mode_template));
      // memcpy(ci.map_param[i],map+i,sizeof(*map));

      ci.mode_param[i] = new vorbis_info_mode(mode[i]);
      if (i >= ci.modes) ci.modes = i + 1;

      ci.map_type[i] = 0;

      ci.map_param[i] = new vorbis_info_mapping0(map[i]);

      if (i >= ci.maps) ci.maps = i + 1;

      for (j = 0; j < map[i].submaps; j++)
        vorbis_encode_residue_setup(map[i].residuesubmap[j], i, res[map[i].residuesubmap[j]]);
    }
  }
Ejemplo n.º 3
0
  private void vorbis_encode_psyset_setup(
      float s, int[] nn_start, int[] nn_partition, float[] nn_thresh, int block) {

    codec_setup_info ci = vi.codec_setup;
    highlevel_encode_setup hi = ci.hi;
    int is = new Float(s).intValue();

    if (block >= ci.psys) ci.psys = block + 1;

    ci.psy_param[block] =
        new vorbis_info_psy(

            // static vorbis_info_psy _psy_info_template = {
            -1,
            -140.f,
            -140.f,

            // tonemask att boost/decay,suppr,curves
            new float[] {0.f, 0.f, 0.f},
            0.f,
            0.f,
            -40.f,
            new float[] {0.f},

            // noisemaskp,supp, low/high window, low/hi guard, minimum
            1,
            -0.f,
            .5f,
            .5f,
            0,
            0,
            0,
            new float[][] {{-1}, {-1}, {-1}},
            new float[] {-1},
            105.f,
            0,
            0,
            -1,
            -1,
            0.0f);

    vorbis_info_psy p = ci.psy_param[block];

    p.blockflag = block >> 1;

    if (hi.noise_normalize_p != 0) {
      p.normal_channel_p = 1;
      p.normal_point_p = 1;
      p.normal_start = nn_start[is];
      p.normal_partition = nn_partition[is];
      p.normal_thresh = nn_thresh[is];
    }
  }
Ejemplo n.º 4
0
  private void vorbis_encode_residue_setup(int number, int block, vorbis_residue_template res) {

    codec_setup_info ci = vi.codec_setup;
    int i;

    // vorbis_info_residue0 *r = ci.residue_param[number] = _ogg_malloc(sizeof(*r));
    // memcpy(r,res.res,sizeof(*r));

    ci.residue_param[number] = new vorbis_info_residue0(res.res);
    vorbis_info_residue0 r = ci.residue_param[number];

    if (ci.residues <= number) ci.residues = number + 1;

    switch (ci.blocksizes[block]) {
      case 64:
      case 128:
      case 256:
        r.grouping = 16;
        break;

      default:
        r.grouping = 32;
        break;
    }

    ci.residue_type[number] = res.res_type;

    // to be adjusted by lowpass/pointlimit later
    r.end = ci.blocksizes[block] >> 1;
    if (res.res_type == 2) {
      r.end *= vi.channels;
    }

    // fill in all the books
    {
      int booklist = 0, k;

      if (ci.hi.managed != 0) {
        for (i = 0; i < r.partitions; i++)
          for (k = 0; k < 3; k++)
            if (res.books_base_managed.books[i][k] != null) r.secondstages[i] |= (1 << k);

        r.groupbook = book_dup_or_new(ci, res.book_aux_managed);
        ci.book_param[r.groupbook] = res.book_aux_managed;

        for (i = 0; i < r.partitions; i++) {
          for (k = 0; k < 3; k++) {
            if (res.books_base_managed.books[i][k] != null) {
              int bookid = book_dup_or_new(ci, res.books_base_managed.books[i][k]);
              r.booklist[booklist++] = bookid;
              ci.book_param[bookid] = res.books_base_managed.books[i][k];
            }
          }
        }

      } else {

        for (i = 0; i < r.partitions; i++)
          for (k = 0; k < 3; k++)
            if (res.books_base.books[i][k] != null) r.secondstages[i] |= (1 << k);

        r.groupbook = book_dup_or_new(ci, res.book_aux);
        ci.book_param[r.groupbook] = res.book_aux;

        for (i = 0; i < r.partitions; i++) {
          for (k = 0; k < 3; k++) {
            if (res.books_base.books[i][k] != null) {
              int bookid = book_dup_or_new(ci, res.books_base.books[i][k]);
              r.booklist[booklist++] = bookid;
              ci.book_param[bookid] = res.books_base.books[i][k];
            }
          }
        }
      }
    }

    // lowpass setup/pointlimit
    {
      float freq = ci.hi.lowpass_kHz * 1000.0f;
      vorbis_info_floor1 f = ci.floor_param[block]; // by convention
      float nyq = vi.rate / 2.0f;
      int blocksize = ci.blocksizes[block] >> 1;

      // lowpass needs to be set in the floor and the residue.
      if (freq > nyq) freq = nyq;

      // in the floor, the granularity can be very fine; it doesn't alter the
      // encoding structure, only the samples used to fit the floor approximation
      f.n = new Double(freq / nyq * blocksize).intValue();

      // this res may by limited by the maximum pointlimit of the mode,
      // not the lowpass. the floor is always lowpass limited.
      if (res.limit_type != 0) {
        if (ci.hi.managed != 0) freq = ci.psy_g_param.coupling_pkHz[PACKETBLOBS - 1] * 1000.0f;
        else freq = ci.psy_g_param.coupling_pkHz[PACKETBLOBS / 2] * 1000.0f;
        if (freq > nyq) freq = nyq;
      }

      // in the residue, we're constrained, physically, by partition
      // boundaries.  We still lowpass 'wherever', but we have to round up
      // here to next boundary, or the vorbis spec will round it *down* to
      // previous boundary in encode/decode

      if (ci.residue_type[block] == 2)
        r.end =
            new Double((freq / nyq * blocksize * 2) / r.grouping + .9).intValue()
                * r.grouping; // round up only if we're well past
      else
        r.end =
            new Double((freq / nyq * blocksize) / r.grouping + .9).intValue()
                * r.grouping; // round up only if we're well past
    }
  }
Ejemplo n.º 5
0
  public boolean vorbis_encode_setup_init() { // the final setup call

    int i0 = 0;
    int singleblock = 0;

    codec_setup_info ci = vi.codec_setup;
    ve_setup_data_template setup = null;
    highlevel_encode_setup hi = ci.hi;

    if (ci == null) {
      System.out.println("vorbis_info.codec_setup_info doesnt exist");
      return false;
    }

    if (hi.impulse_block_p == 0) i0 = 1;

    // too low/high an ATH floater is nonsensical, but doesn't break anything
    if (hi.ath_floating_dB > -80) hi.ath_floating_dB = -80;
    if (hi.ath_floating_dB < -200) hi.ath_floating_dB = -200;

    // again, bound this to avoid the app shooting itself in the foot
    if (hi.amplitude_track_dBpersec > 0.) hi.amplitude_track_dBpersec = 0.0f;
    if (hi.amplitude_track_dBpersec < -99999.) hi.amplitude_track_dBpersec = -99999.0f;

    // get the appropriate setup template; matches the fetch in previous stages
    setup = hi.setup;
    if (setup == null) {
      System.out.println(
          "vorbis_info.codec_setup.highlevel_encode_setup.ve_setup_data_template doesnt exist");
      return false;
    }

    hi.set_in_stone = 1;

    // choose block sizes from configured sizes as well as paying attention
    // to long_block_p and short_block_p.  If the configured short and long
    // blocks are the same length, we set long_block_p and unset short_block_p

    vorbis_encode_blocksize_setup(hi.base_setting, setup.blocksize_short, setup.blocksize_long);
    if (ci.blocksizes[0] == ci.blocksizes[1]) singleblock = 1;

    // floor setup; choose proper floor params.  Allocated on the floor stack in order; if we alloc
    // only long floor, it's 0
    vorbis_encode_floor_setup(
        hi.short_setting, 0, setup.floor_books, setup.floor_params, setup.floor_short_mapping);
    if (singleblock == 0)
      vorbis_encode_floor_setup(
          hi.long_setting, 1, setup.floor_books, setup.floor_params, setup.floor_long_mapping);

    // setup of [mostly] short block detection and stereo
    vorbis_encode_global_psych_setup(hi.trigger_setting, setup.global_params, setup.global_mapping);
    vorbis_encode_global_stereo(hi, setup.stereo_modes);

    // basic psych setup and noise normalization
    vorbis_encode_psyset_setup(
        hi.short_setting,
        setup.psy_noise_normal_start[0],
        setup.psy_noise_normal_partition[0],
        setup.psy_noise_normal_thresh,
        0);
    vorbis_encode_psyset_setup(
        hi.short_setting,
        setup.psy_noise_normal_start[0],
        setup.psy_noise_normal_partition[0],
        setup.psy_noise_normal_thresh,
        1);
    if (singleblock == 0) {
      vorbis_encode_psyset_setup(
          hi.long_setting,
          setup.psy_noise_normal_start[1],
          setup.psy_noise_normal_partition[1],
          setup.psy_noise_normal_thresh,
          2);
      vorbis_encode_psyset_setup(
          hi.long_setting,
          setup.psy_noise_normal_start[1],
          setup.psy_noise_normal_partition[1],
          setup.psy_noise_normal_thresh,
          3);
    }

    // tone masking setup
    vorbis_encode_tonemask_setup(
        hi.block[i0].tone_mask_setting,
        0,
        setup.psy_tone_masteratt,
        setup.psy_tone_0dB,
        setup.psy_tone_adj_impulse);
    vorbis_encode_tonemask_setup(
        hi.block[1].tone_mask_setting,
        1,
        setup.psy_tone_masteratt,
        setup.psy_tone_0dB,
        setup.psy_tone_adj_other);
    if (singleblock == 0) {
      vorbis_encode_tonemask_setup(
          hi.block[2].tone_mask_setting,
          2,
          setup.psy_tone_masteratt,
          setup.psy_tone_0dB,
          setup.psy_tone_adj_other);
      vorbis_encode_tonemask_setup(
          hi.block[3].tone_mask_setting,
          3,
          setup.psy_tone_masteratt,
          setup.psy_tone_0dB,
          setup.psy_tone_adj_long);
    }

    // noise companding setup
    vorbis_encode_compand_setup(
        hi.block[i0].noise_compand_setting,
        0,
        setup.psy_noise_compand,
        setup.psy_noise_compand_short_mapping);
    vorbis_encode_compand_setup(
        hi.block[1].noise_compand_setting,
        1,
        setup.psy_noise_compand,
        setup.psy_noise_compand_short_mapping);
    if (singleblock == 0) {
      vorbis_encode_compand_setup(
          hi.block[2].noise_compand_setting,
          2,
          setup.psy_noise_compand,
          setup.psy_noise_compand_long_mapping);
      vorbis_encode_compand_setup(
          hi.block[3].noise_compand_setting,
          3,
          setup.psy_noise_compand,
          setup.psy_noise_compand_long_mapping);
    }

    // peak guarding setup
    vorbis_encode_peak_setup(hi.block[i0].tone_peaklimit_setting, 0, setup.psy_tone_dBsuppress);
    vorbis_encode_peak_setup(hi.block[1].tone_peaklimit_setting, 1, setup.psy_tone_dBsuppress);
    if (singleblock == 0) {
      vorbis_encode_peak_setup(hi.block[2].tone_peaklimit_setting, 2, setup.psy_tone_dBsuppress);
      vorbis_encode_peak_setup(hi.block[3].tone_peaklimit_setting, 3, setup.psy_tone_dBsuppress);
    }

    // noise bias setup
    float userbias = 0;
    if (i0 == 0) userbias = hi.impulse_noisetune;
    vorbis_encode_noisebias_setup(
        hi.block[i0].noise_bias_setting,
        0,
        setup.psy_noise_dBsuppress,
        setup.psy_noise_bias_impulse,
        setup.psy_noiseguards,
        userbias);
    vorbis_encode_noisebias_setup(
        hi.block[1].noise_bias_setting,
        1,
        setup.psy_noise_dBsuppress,
        setup.psy_noise_bias_padding,
        setup.psy_noiseguards,
        0.0f);
    if (singleblock == 0) {
      vorbis_encode_noisebias_setup(
          hi.block[2].noise_bias_setting,
          2,
          setup.psy_noise_dBsuppress,
          setup.psy_noise_bias_trans,
          setup.psy_noiseguards,
          0.0f);
      vorbis_encode_noisebias_setup(
          hi.block[3].noise_bias_setting,
          3,
          setup.psy_noise_dBsuppress,
          setup.psy_noise_bias_long,
          setup.psy_noiseguards,
          0.0f);
    }

    vorbis_encode_ath_setup(0);
    vorbis_encode_ath_setup(1);
    if (singleblock == 0) {
      vorbis_encode_ath_setup(2);
      vorbis_encode_ath_setup(3);
    }

    vorbis_encode_map_n_res_setup(hi.base_setting, setup.maps);

    // set bitrate readonlies and management
    if (hi.bitrate_av > 0) vi.bitrate_nominal = hi.bitrate_av;
    else vi.bitrate_nominal = new Float(setting_to_approx_bitrate()).intValue();

    vi.bitrate_lower = hi.bitrate_min;
    vi.bitrate_upper = hi.bitrate_max;
    if (hi.bitrate_av > 0) vi.bitrate_window = hi.bitrate_reservoir / hi.bitrate_av;
    else vi.bitrate_window = 0;

    if (hi.managed > 0) {

      ci.bi =
          new bitrate_manager_info(
              hi.bitrate_av,
              hi.bitrate_min,
              hi.bitrate_max,
              hi.bitrate_reservoir,
              hi.bitrate_reservoir_bias,
              hi.bitrate_av_damp);
    }

    return true;
  }