Пример #1
0
  private boolean get_setup_template(int ch, int srate, float req, int q_or_bitrate) {

    int i = 0, j;
    highlevel_encode_setup hi = vi.codec_setup.hi;

    if (q_or_bitrate > 0) req /= ch;

    while (setup_list[i] != null) {

      if (setup_list[i].coupling_restriction == -1 || setup_list[i].coupling_restriction == ch) {

        if (srate >= setup_list[i].samplerate_min_restriction
            && srate <= setup_list[i].samplerate_max_restriction) {

          int mappings = setup_list[i].mappings;
          float[] map;
          if (q_or_bitrate > 0) map = setup_list[i].rate_mapping;
          else map = setup_list[i].quality_mapping;

          // the template matches.  Does the requested quality mode fall within this templates
          // modes?
          if (req < map[0]) {
            ++i;
            continue;
          }

          if (req > map[setup_list[i].mappings]) {
            ++i;
            continue;
          }

          for (j = 0; j < mappings; j++) if (req >= map[j] && req < map[j + 1]) break;

          // an all points match
          hi.setup = setup_list[i];

          if (j == mappings) hi.base_setting = j - .001f;
          else {
            float low = map[j];
            float high = map[j + 1];
            float del = (req - low) / (high - low);
            hi.base_setting = j + del;
          }

          return true;
        }
      }
      i++;
    }
    hi.setup = null;
    return false;
  }
Пример #2
0
  public boolean vorbis_encode_setup_managed(
      vorbis_info _vi,
      int channels,
      int rate,
      int max_bitrate,
      int nominal_bitrate,
      int min_bitrate) {

    vi = _vi;

    float tnominal = new Integer(nominal_bitrate).floatValue();

    if (nominal_bitrate <= 0.) {
      if (max_bitrate > 0.) {
        if (min_bitrate > 0.)
          nominal_bitrate = new Double((max_bitrate + min_bitrate) * .5).intValue();
        else nominal_bitrate = new Double(max_bitrate * .875).intValue();
      } else {
        if (min_bitrate > 0.) nominal_bitrate = min_bitrate;
        else return false;
      }
    }

    if (!get_setup_template(channels, rate, nominal_bitrate, 1)) {
      System.out.println(
          "Unable to find setup template - "
              + channels
              + " channels, "
              + rate
              + " rate, "
              + nominal_bitrate
              + " nominal_bitrate");
      return false;
    }

    vorbis_encode_setup_setting(channels, rate);

    highlevel_encode_setup hi = vi.codec_setup.hi;

    // initialize management with sane defaults
    hi.managed = 1;
    hi.bitrate_min = min_bitrate;
    hi.bitrate_max = max_bitrate;
    hi.bitrate_av = new Float(tnominal).intValue();
    hi.bitrate_av_damp = 1.5f;
    hi.bitrate_reservoir = nominal_bitrate * 2;
    hi.bitrate_reservoir_bias = .1f; // bias toward hoarding bits

    return true;
  }
Пример #3
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;
  }
Пример #4
0
  private boolean vorbis_encode_setup_setting(int channels, int rate) {

    int i, is;

    codec_setup_info ci = vi.codec_setup;
    highlevel_encode_setup hi = ci.hi;
    ve_setup_data_template setup = hi.setup;
    float ds; // double

    // vorbis_encode_toplevel_setup(vorbis_info *vi,int ch,long rate)
    vi.version = 0;
    vi.channels = channels;
    vi.rate = rate;

    is = new Float(hi.base_setting).intValue();
    ds = hi.base_setting - is;

    hi.short_setting = hi.base_setting;
    hi.long_setting = hi.base_setting;

    hi.managed = 0;

    hi.impulse_block_p = 1;
    hi.noise_normalize_p = 1;

    hi.stereo_point_setting = hi.base_setting;
    hi.lowpass_kHz = setup.psy_lowpass[is] * (1.0f - ds) + setup.psy_lowpass[is + 1] * ds;

    hi.ath_floating_dB = setup.psy_ath_float[is] * (1.0f - ds) + setup.psy_ath_float[is + 1] * ds;
    hi.ath_absolute_dB = setup.psy_ath_abs[is] * (1.0f - ds) + setup.psy_ath_abs[is + 1] * ds;

    hi.amplitude_track_dBpersec = -6.0f;
    hi.trigger_setting = hi.base_setting;

    for (i = 0; i < 4; i++)
      hi.block[i] =
          new highlevel_byblocktype(
              hi.base_setting, hi.base_setting, hi.base_setting, hi.base_setting);

    return true;
  }
Пример #5
0
  public Object vorbis_encode_ctl(vorbis_info _vi, int number, Object arg) {

    if (_vi == null) return false;

    codec_setup_info ci = vi.codec_setup;
    highlevel_encode_setup hi = ci.hi;
    int setp = (number & 0xf); // a read request has a low nibble of 0

    if ((setp > 0) && (hi.set_in_stone > 0)) return false;

    switch (number) {

        // now deprecated *****************
        /*
        case OV_ECTL_RATEMANAGE_GET: {

        	ovectl_ratemanage_arg ai= ( ovectl_ratemanage_arg )arg;

        	ai.management_active=hi.managed;
        	ai.bitrate_hard_window=ai.bitrate_av_window=(double)hi.bitrate_reservoir/vi.rate;
        	ai.bitrate_av_window_center=1.;
        	ai.bitrate_hard_min=hi.bitrate_min;
        	ai.bitrate_hard_max=hi.bitrate_max;
        	ai.bitrate_av_lo=hi.bitrate_av;
        	ai.bitrate_av_hi=hi.bitrate_av;
        }
        return true;

        // now deprecated *****************
        case OV_ECTL_RATEMANAGE_SET: {

        	ovectl_ratemanage_arg ai= ( ovectl_ratemanage_arg )arg;

        	if ( ai == null ) {
        		hi.managed=0;
        	} else {
        		hi.managed=ai.management_active;
        		vorbis_encode_ctl( vi, OV_ECTL_RATEMANAGE_AVG, arg );
        		vorbis_encode_ctl( vi, OV_ECTL_RATEMANAGE_HARD, arg );
        	}
        }
        return true;

        // now deprecated *****************
        case OV_ECTL_RATEMANAGE_AVG: {

        	ovectl_ratemanage_arg ai= ( ovectl_ratemanage_arg )arg;

        	if (ai == null) {
        		hi.bitrate_av=0;
        	} else {
        		hi.bitrate_av=(ai.bitrate_av_lo+ai.bitrate_av_hi)*.5;
        	}
        }
        return true;

        // now deprecated *****************
        case OV_ECTL_RATEMANAGE_HARD: {

        	ovectl_ratemanage_arg ai= ( ovectl_ratemanage_arg )arg;

        	if (ai == null ) {
        		hi.bitrate_min=0;
        		hi.bitrate_max=0;
        	} else {
        		hi.bitrate_min=ai.bitrate_hard_min;
        		hi.bitrate_max=ai.bitrate_hard_max;
        		hi.bitrate_reservoir=ai.bitrate_hard_window*(hi.bitrate_max+hi.bitrate_min)*.5;
        	}
        	if ( hi.bitrate_reservoir < 128.f )
        		hi.bitrate_reservoir=128;
        }
        return true;
        */

        // replacement ratemanage interface
      case OV_ECTL_RATEMANAGE2_GET:
        {
          ovectl_ratemanage2_arg ai = (ovectl_ratemanage2_arg) arg;

          if (ai == null) return false;

          ai.management_active = hi.managed;
          ai.bitrate_limit_min_kbps = hi.bitrate_min / 1000;
          ai.bitrate_limit_max_kbps = hi.bitrate_max / 1000;
          ai.bitrate_average_kbps = hi.bitrate_av / 1000;
          ai.bitrate_average_damping = hi.bitrate_av_damp;
          ai.bitrate_limit_reservoir_bits = hi.bitrate_reservoir;
          ai.bitrate_limit_reservoir_bias = hi.bitrate_reservoir_bias;

          return ai;
        }

      case OV_ECTL_RATEMANAGE2_SET:
        {
          ovectl_ratemanage2_arg ai = (ovectl_ratemanage2_arg) arg;

          if (ai == null) {
            hi.managed = 0;
          } else {
            // sanity check; only catch invariant violations
            if (ai.bitrate_limit_min_kbps > 0
                && ai.bitrate_average_kbps > 0
                && ai.bitrate_limit_min_kbps > ai.bitrate_average_kbps) return false;

            if (ai.bitrate_limit_max_kbps > 0
                && ai.bitrate_average_kbps > 0
                && ai.bitrate_limit_max_kbps < ai.bitrate_average_kbps) return false;

            if (ai.bitrate_limit_min_kbps > 0
                && ai.bitrate_limit_max_kbps > 0
                && ai.bitrate_limit_min_kbps > ai.bitrate_limit_max_kbps) return false;

            if (ai.bitrate_average_damping <= 0.) return false;

            if (ai.bitrate_limit_reservoir_bits < 0) return false;

            if (ai.bitrate_limit_reservoir_bias < 0.) return false;

            if (ai.bitrate_limit_reservoir_bias > 1.) return false;

            hi.managed = ai.management_active;
            hi.bitrate_min = ai.bitrate_limit_min_kbps * 1000;
            hi.bitrate_max = ai.bitrate_limit_max_kbps * 1000;
            hi.bitrate_av = ai.bitrate_average_kbps * 1000;
            hi.bitrate_av_damp = ai.bitrate_average_damping;
            hi.bitrate_reservoir = ai.bitrate_limit_reservoir_bits;
            hi.bitrate_reservoir_bias = ai.bitrate_limit_reservoir_bias;
          }
        }
        return true;

      case OV_ECTL_LOWPASS_GET:
        {
          return hi.lowpass_kHz;
        }

      case OV_ECTL_LOWPASS_SET:
        {
          hi.lowpass_kHz = (Float) arg;

          if (hi.lowpass_kHz < 2.f) hi.lowpass_kHz = 2.f;
          if (hi.lowpass_kHz > 99.f) hi.lowpass_kHz = 99.f;
        }
        return true;

      case OV_ECTL_IBLOCK_GET:
        {
          return hi.impulse_noisetune;
        }

      case OV_ECTL_IBLOCK_SET:
        {
          hi.impulse_noisetune = (Float) arg;

          if (hi.impulse_noisetune > 0.f) hi.impulse_noisetune = 0.f;
          if (hi.impulse_noisetune < -15.f) hi.impulse_noisetune = -15.f;
        }
        return true;
    }
    return true;
  }