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;
}
// 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]]);
}
}
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];
}
}
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
}
}
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;
}
