Ejemplo n.º 1
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;
  }
Ejemplo n.º 2
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;
  }