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;
}
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;
}
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;
}
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;
}
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;
}