int toolame_set_bitrate(int brate)
{
int err = 0;
/* check for a valid bitrate */
if (brate == 0)
brate = bitrate[header.version][10];
/* Check to see we have a sane value for the bitrate for this version */
if ((header.bitrate_index = BitrateIndex (brate, header.version)) < 0) {
err = 1;
}
if (header.dab_extension) {
/* in 48 kHz (= MPEG-1) */
/* if the bit rate per channel is less then 56 kbit/s, we have 2 scf-crc */
/* else we have 4 scf-crc */
/* in 24 kHz (= MPEG-2), we have 4 scf-crc */
if (header.version == MPEG_AUDIO_ID && (brate / (header.mode == MPG_MD_MONO ? 1 : 2) < 56))
header.dab_extension = 2;
}
open_bit_stream_w(&bs, BUFFER_SIZE);
return err;
}
int
lame_init_params(lame_global_flags * gfp)
{
int i;
int j;
lame_internal_flags *const gfc = gfp->internal_flags;
SessionConfig_t *const cfg = &gfc->cfg;
gfc->class_id = 0;
cfg->enforce_min_bitrate = gfp->VBR_hard_min;
cfg->analysis = gfp->analysis;
if (cfg->analysis)
gfp->write_lame_tag = 0;
/* some file options not allowed if output is: not specified or stdout */
if (gfc->pinfo != NULL)
gfp->write_lame_tag = 0; /* disable Xing VBR tag */
/* report functions */
gfc->report_msg = gfp->report.msgf;
gfc->report_dbg = gfp->report.debugf;
gfc->report_err = gfp->report.errorf;
if (gfp->asm_optimizations.amd3dnow)
gfc->CPU_features.AMD_3DNow = has_3DNow();
else
gfc->CPU_features.AMD_3DNow = 0;
if (gfp->asm_optimizations.mmx)
gfc->CPU_features.MMX = has_MMX();
else
gfc->CPU_features.MMX = 0;
if (gfp->asm_optimizations.sse) {
gfc->CPU_features.SSE = has_SSE();
gfc->CPU_features.SSE2 = has_SSE2();
}
else {
gfc->CPU_features.SSE = 0;
gfc->CPU_features.SSE2 = 0;
}
if (NULL == gfc->ATH)
gfc->ATH = calloc(1, sizeof(ATH_t));
if (NULL == gfc->ATH)
return -2; /* maybe error codes should be enumerated in lame.h ?? */
if (NULL == gfc->sv_rpg.rgdata)
gfc->sv_rpg.rgdata = calloc(1, sizeof(replaygain_t));
if (NULL == gfc->sv_rpg.rgdata) {
freegfc(gfc);
gfp->internal_flags = NULL;
return -2;
}
cfg->error_protection = gfp->error_protection;
cfg->copyright = gfp->copyright;
cfg->original = gfp->original;
cfg->extension = gfp->extension;
cfg->emphasis = gfp->emphasis;
cfg->channels_in = gfp->num_channels;
if (cfg->channels_in == 1)
gfp->mode = MONO;
cfg->channels_out = (gfp->mode == MONO) ? 1 : 2;
if (gfp->mode == MONO)
gfp->force_ms = 0; /* don't allow forced mid/side stereo for mono output */
cfg->force_ms = gfp->force_ms;
if (gfp->VBR == vbr_off && gfp->VBR_mean_bitrate_kbps != 128 && gfp->brate == 0)
gfp->brate = gfp->VBR_mean_bitrate_kbps;
switch (gfp->VBR) {
case vbr_off:
case vbr_mtrh:
case vbr_mt:
/* these modes can handle free format condition */
break;
default:
gfp->free_format = 0; /* mode can't be mixed with free format */
break;
}
cfg->free_format = gfp->free_format;
if (gfp->VBR == vbr_off && gfp->brate == 0) {
/* no bitrate or compression ratio specified, use 11.025 */
if (EQ(gfp->compression_ratio, 0))
gfp->compression_ratio = 11.025; /* rate to compress a CD down to exactly 128000 bps */
}
/* find bitrate if user specify a compression ratio */
if (gfp->VBR == vbr_off && gfp->compression_ratio > 0) {
if (gfp->samplerate_out == 0)
gfp->samplerate_out = map2MP3Frequency((int) (0.97 * gfp->samplerate_in)); /* round up with a margin of 3% */
/* choose a bitrate for the output samplerate which achieves
* specified compression ratio
*/
gfp->brate = gfp->samplerate_out * 16 * cfg->channels_out / (1.e3 * gfp->compression_ratio);
/* we need the version for the bitrate table look up */
cfg->samplerate_index = SmpFrqIndex(gfp->samplerate_out, &cfg->version);
if (!cfg->free_format) /* for non Free Format find the nearest allowed bitrate */
gfp->brate = FindNearestBitrate(gfp->brate, cfg->version, gfp->samplerate_out);
}
if (gfp->samplerate_out) {
if (gfp->samplerate_out < 16000) {
gfp->VBR_mean_bitrate_kbps = Max(gfp->VBR_mean_bitrate_kbps, 8);
gfp->VBR_mean_bitrate_kbps = Min(gfp->VBR_mean_bitrate_kbps, 64);
}
else if (gfp->samplerate_out < 32000) {
gfp->VBR_mean_bitrate_kbps = Max(gfp->VBR_mean_bitrate_kbps, 8);
gfp->VBR_mean_bitrate_kbps = Min(gfp->VBR_mean_bitrate_kbps, 160);
}
else {
gfp->VBR_mean_bitrate_kbps = Max(gfp->VBR_mean_bitrate_kbps, 32);
gfp->VBR_mean_bitrate_kbps = Min(gfp->VBR_mean_bitrate_kbps, 320);
}
}
/* WORK IN PROGRESS */
/* mapping VBR scale to internal VBR quality settings */
if (gfp->samplerate_out == 0 && (gfp->VBR == vbr_mt || gfp->VBR == vbr_mtrh)) {
float const qval = gfp->VBR_q + gfp->VBR_q_frac;
struct q_map { int sr_a; float qa, qb, ta, tb; int lp; };
struct q_map const m[9]
= { {48000, 0.0,6.5, 0.0,6.5, 23700}
, {44100, 0.0,6.5, 0.0,6.5, 21780}
, {32000, 6.5,8.0, 5.2,6.5, 15800}
, {24000, 8.0,8.5, 5.2,6.0, 11850}
, {22050, 8.5,9.01, 5.2,6.5, 10892}
, {16000, 9.01,9.4, 4.9,6.5, 7903}
, {12000, 9.4,9.6, 4.5,6.0, 5928}
, {11025, 9.6,9.9, 5.1,6.5, 5446}
, { 8000, 9.9,10., 4.9,6.5, 3952}
};
for (i = 2; i < 9; ++i) {
if (gfp->samplerate_in == m[i].sr_a) {
if (qval < m[i].qa) {
double d = qval / m[i].qa;
d = d * m[i].ta;
gfp->VBR_q = (int)d;
gfp->VBR_q_frac = d - gfp->VBR_q;
}
}
if (gfp->samplerate_in >= m[i].sr_a) {
if (m[i].qa <= qval && qval < m[i].qb) {
float const q_ = m[i].qb-m[i].qa;
float const t_ = m[i].tb-m[i].ta;
double d = m[i].ta + t_ * (qval-m[i].qa) / q_;
gfp->VBR_q = (int)d;
gfp->VBR_q_frac = d - gfp->VBR_q;
gfp->samplerate_out = m[i].sr_a;
if (gfp->lowpassfreq == 0) {
gfp->lowpassfreq = -1;
}
break;
}
}
}
}
/****************************************************************/
/* if a filter has not been enabled, see if we should add one: */
/****************************************************************/
if (gfp->lowpassfreq == 0) {
double lowpass = 16000;
double highpass;
switch (gfp->VBR) {
case vbr_off:{
optimum_bandwidth(&lowpass, &highpass, gfp->brate);
break;
}
case vbr_abr:{
optimum_bandwidth(&lowpass, &highpass, gfp->VBR_mean_bitrate_kbps);
break;
}
case vbr_rh:{
int const x[11] = {
19500, 19000, 18600, 18000, 17500, 16000, 15600, 14900, 12500, 10000, 3950
};
if (0 <= gfp->VBR_q && gfp->VBR_q <= 9) {
double a = x[gfp->VBR_q], b = x[gfp->VBR_q + 1], m = gfp->VBR_q_frac;
lowpass = linear_int(a, b, m);
}
else {
lowpass = 19500;
}
break;
}
case vbr_mtrh:
case vbr_mt:{
int const x[11] = {
24000, 19500, 18500, 18000, 17500, 17000, 16500, 15600, 15200, 7230, 3950
};
if (0 <= gfp->VBR_q && gfp->VBR_q <= 9) {
double a = x[gfp->VBR_q], b = x[gfp->VBR_q + 1], m = gfp->VBR_q_frac;
lowpass = linear_int(a, b, m);
}
else {
lowpass = 21500;
}
break;
}
default:{
int const x[11] = {
19500, 19000, 18500, 18000, 17500, 16500, 15500, 14500, 12500, 9500, 3950
};
if (0 <= gfp->VBR_q && gfp->VBR_q <= 9) {
double a = x[gfp->VBR_q], b = x[gfp->VBR_q + 1], m = gfp->VBR_q_frac;
lowpass = linear_int(a, b, m);
}
else {
lowpass = 19500;
}
}
}
if (gfp->mode == MONO && (gfp->VBR == vbr_off || gfp->VBR == vbr_abr))
lowpass *= 1.5;
gfp->lowpassfreq = lowpass;
}
if (gfp->samplerate_out == 0) {
if (2 * gfp->lowpassfreq > gfp->samplerate_in) {
gfp->lowpassfreq = gfp->samplerate_in / 2;
}
gfp->samplerate_out = optimum_samplefreq((int) gfp->lowpassfreq, gfp->samplerate_in);
}
if (gfp->VBR == vbr_mt || gfp->VBR == vbr_mtrh) {
gfp->lowpassfreq = Min(24000, gfp->lowpassfreq);
}
else {
gfp->lowpassfreq = Min(20500, gfp->lowpassfreq);
}
gfp->lowpassfreq = Min(gfp->samplerate_out / 2, gfp->lowpassfreq);
if (gfp->VBR == vbr_off) {
gfp->compression_ratio = gfp->samplerate_out * 16 * cfg->channels_out / (1.e3 * gfp->brate);
}
if (gfp->VBR == vbr_abr) {
gfp->compression_ratio =
gfp->samplerate_out * 16 * cfg->channels_out / (1.e3 * gfp->VBR_mean_bitrate_kbps);
}
/* do not compute ReplayGain values and do not find the peak sample
if we can't store them */
if (!gfp->write_lame_tag) {
gfp->findReplayGain = 0;
gfp->decode_on_the_fly = 0;
cfg->findPeakSample = 0;
}
cfg->findReplayGain = gfp->findReplayGain;
cfg->decode_on_the_fly = gfp->decode_on_the_fly;
if (cfg->decode_on_the_fly)
cfg->findPeakSample = 1;
if (cfg->findReplayGain) {
if (InitGainAnalysis(gfc->sv_rpg.rgdata, gfp->samplerate_out) == INIT_GAIN_ANALYSIS_ERROR) {
freegfc(gfc);
gfp->internal_flags = NULL;
return -6;
}
}
#ifdef DECODE_ON_THE_FLY
if (cfg->decode_on_the_fly && !gfp->decode_only) {
if (gfc->hip) {
hip_decode_exit(gfc->hip);
}
gfc->hip = hip_decode_init();
/* report functions */
hip_set_errorf(gfc->hip, gfp->report.errorf);
hip_set_debugf(gfc->hip, gfp->report.debugf);
hip_set_msgf(gfc->hip, gfp->report.msgf);
}
#endif
cfg->disable_reservoir = gfp->disable_reservoir;
cfg->lowpassfreq = gfp->lowpassfreq;
cfg->highpassfreq = gfp->highpassfreq;
cfg->samplerate_in = gfp->samplerate_in;
cfg->samplerate_out = gfp->samplerate_out;
cfg->mode_gr = cfg->samplerate_out <= 24000 ? 1 : 2; /* Number of granules per frame */
gfc->ov_enc.encoder_delay = ENCDELAY;
/*
* sample freq bitrate compression ratio
* [kHz] [kbps/channel] for 16 bit input
* 44.1 56 12.6
* 44.1 64 11.025
* 44.1 80 8.82
* 22.05 24 14.7
* 22.05 32 11.025
* 22.05 40 8.82
* 16 16 16.0
* 16 24 10.667
*
*/
/*
* For VBR, take a guess at the compression_ratio.
* For example:
*
* VBR_q compression like
* - 4.4 320 kbps/44 kHz
* 0...1 5.5 256 kbps/44 kHz
* 2 7.3 192 kbps/44 kHz
* 4 8.8 160 kbps/44 kHz
* 6 11 128 kbps/44 kHz
* 9 14.7 96 kbps
*
* for lower bitrates, downsample with --resample
*/
switch (gfp->VBR) {
case vbr_mt:
case vbr_rh:
case vbr_mtrh:
{
/*numbers are a bit strange, but they determine the lowpass value */
FLOAT const cmp[] = { 5.7, 6.5, 7.3, 8.2, 10, 11.9, 13, 14, 15, 16.5 };
gfp->compression_ratio = cmp[gfp->VBR_q];
}
break;
case vbr_abr:
gfp->compression_ratio =
cfg->samplerate_out * 16 * cfg->channels_out / (1.e3 * gfp->VBR_mean_bitrate_kbps);
break;
default:
gfp->compression_ratio = cfg->samplerate_out * 16 * cfg->channels_out / (1.e3 * gfp->brate);
break;
}
/* mode = -1 (not set by user) or
* mode = MONO (because of only 1 input channel).
* If mode has not been set, then select J-STEREO
*/
if (gfp->mode == NOT_SET) {
gfp->mode = JOINT_STEREO;
}
cfg->mode = gfp->mode;
/* apply user driven high pass filter */
if (cfg->highpassfreq > 0) {
cfg->highpass1 = 2. * cfg->highpassfreq;
if (gfp->highpasswidth >= 0)
cfg->highpass2 = 2. * (cfg->highpassfreq + gfp->highpasswidth);
else /* 0% above on default */
cfg->highpass2 = (1 + 0.00) * 2. * cfg->highpassfreq;
cfg->highpass1 /= cfg->samplerate_out;
cfg->highpass2 /= cfg->samplerate_out;
}
else {
cfg->highpass1 = 0;
cfg->highpass2 = 0;
}
/* apply user driven low pass filter */
cfg->lowpass1 = 0;
cfg->lowpass2 = 0;
if (cfg->lowpassfreq > 0 && cfg->lowpassfreq < (cfg->samplerate_out / 2) ) {
cfg->lowpass2 = 2. * cfg->lowpassfreq;
if (gfp->lowpasswidth >= 0) {
cfg->lowpass1 = 2. * (cfg->lowpassfreq - gfp->lowpasswidth);
if (cfg->lowpass1 < 0) /* has to be >= 0 */
cfg->lowpass1 = 0;
}
else { /* 0% below on default */
cfg->lowpass1 = (1 - 0.00) * 2. * cfg->lowpassfreq;
}
cfg->lowpass1 /= cfg->samplerate_out;
cfg->lowpass2 /= cfg->samplerate_out;
}
/**********************************************************************/
/* compute info needed for polyphase filter (filter type==0, default) */
/**********************************************************************/
lame_init_params_ppflt(gfc);
/*******************************************************
* samplerate and bitrate index
*******************************************************/
cfg->samplerate_index = SmpFrqIndex(cfg->samplerate_out, &cfg->version);
if (cfg->samplerate_index < 0) {
freegfc(gfc);
gfp->internal_flags = NULL;
return -1;
}
if (gfp->VBR == vbr_off) {
if (cfg->free_format) {
gfc->ov_enc.bitrate_index = 0;
}
else {
gfp->brate = FindNearestBitrate(gfp->brate, cfg->version, cfg->samplerate_out);
gfc->ov_enc.bitrate_index = BitrateIndex(gfp->brate, cfg->version, cfg->samplerate_out);
if (gfc->ov_enc.bitrate_index <= 0) {
freegfc(gfc);
gfp->internal_flags = NULL;
return -1;
}
}
}
else {
gfc->ov_enc.bitrate_index = 1;
}
init_bit_stream_w(gfc);
j = cfg->samplerate_index + (3 * cfg->version) + 6 * (cfg->samplerate_out < 16000);
for (i = 0; i < SBMAX_l + 1; i++)
gfc->scalefac_band.l[i] = sfBandIndex[j].l[i];
for (i = 0; i < PSFB21 + 1; i++) {
int const size = (gfc->scalefac_band.l[22] - gfc->scalefac_band.l[21]) / PSFB21;
int const start = gfc->scalefac_band.l[21] + i * size;
gfc->scalefac_band.psfb21[i] = start;
}
gfc->scalefac_band.psfb21[PSFB21] = 576;
for (i = 0; i < SBMAX_s + 1; i++)
gfc->scalefac_band.s[i] = sfBandIndex[j].s[i];
for (i = 0; i < PSFB12 + 1; i++) {
int const size = (gfc->scalefac_band.s[13] - gfc->scalefac_band.s[12]) / PSFB12;
int const start = gfc->scalefac_band.s[12] + i * size;
gfc->scalefac_band.psfb12[i] = start;
}
gfc->scalefac_band.psfb12[PSFB12] = 192;
/* determine the mean bitrate for main data */
if (cfg->mode_gr == 2) /* MPEG 1 */
cfg->sideinfo_len = (cfg->channels_out == 1) ? 4 + 17 : 4 + 32;
else /* MPEG 2 */
cfg->sideinfo_len = (cfg->channels_out == 1) ? 4 + 9 : 4 + 17;
if (cfg->error_protection)
cfg->sideinfo_len += 2;
gfc->class_id = LAME_ID;
{
int k;
for (k = 0; k < 19; k++)
gfc->sv_enc.pefirbuf[k] = 700 * cfg->mode_gr * cfg->channels_out;
if (gfp->ATHtype == -1)
gfp->ATHtype = 4;
}
assert(gfp->VBR_q <= 9);
assert(gfp->VBR_q >= 0);
switch (gfp->VBR) {
case vbr_mt:
case vbr_mtrh:{
if (gfp->strict_ISO < 0) {
gfp->strict_ISO = MDB_MAXIMUM;
}
if (gfp->useTemporal < 0) {
gfp->useTemporal = 0; /* off by default for this VBR mode */
}
(void) apply_preset(gfp, 500 - (gfp->VBR_q * 10), 0);
/* The newer VBR code supports only a limited
subset of quality levels:
9-5=5 are the same, uses x^3/4 quantization
4-0=0 are the same 5 plus best huffman divide code
*/
if (gfp->quality < 0)
gfp->quality = LAME_DEFAULT_QUALITY;
if (gfp->quality < 5)
gfp->quality = 0;
if (gfp->quality > 7)
gfp->quality = 7;
/* sfb21 extra only with MPEG-1 at higher sampling rates
*/
if (gfp->experimentalY)
gfc->sv_qnt.sfb21_extra = 0;
else
gfc->sv_qnt.sfb21_extra = (cfg->samplerate_out > 44000);
gfc->iteration_loop = VBR_new_iteration_loop;
break;
}
case vbr_rh:{
(void) apply_preset(gfp, 500 - (gfp->VBR_q * 10), 0);
/* sfb21 extra only with MPEG-1 at higher sampling rates
*/
if (gfp->experimentalY)
gfc->sv_qnt.sfb21_extra = 0;
else
gfc->sv_qnt.sfb21_extra = (cfg->samplerate_out > 44000);
/* VBR needs at least the output of GPSYCHO,
* so we have to garantee that by setting a minimum
* quality level, actually level 6 does it.
* down to level 6
*/
if (gfp->quality > 6)
gfp->quality = 6;
if (gfp->quality < 0)
gfp->quality = LAME_DEFAULT_QUALITY;
gfc->iteration_loop = VBR_old_iteration_loop;
break;
}
default: /* cbr/abr */ {
vbr_mode vbrmode;
/* no sfb21 extra with CBR code
*/
gfc->sv_qnt.sfb21_extra = 0;
if (gfp->quality < 0)
gfp->quality = LAME_DEFAULT_QUALITY;
vbrmode = gfp->VBR;
if (vbrmode == vbr_off)
(void) lame_set_VBR_mean_bitrate_kbps(gfp, gfp->brate);
/* second, set parameters depending on bitrate */
(void) apply_preset(gfp, gfp->VBR_mean_bitrate_kbps, 0);
gfp->VBR = vbrmode;
if (vbrmode == vbr_off) {
gfc->iteration_loop = CBR_iteration_loop;
}
else {
gfc->iteration_loop = ABR_iteration_loop;
}
break;
}
}
/*initialize default values common for all modes */
gfc->sv_qnt.mask_adjust = gfp->maskingadjust;
gfc->sv_qnt.mask_adjust_short = gfp->maskingadjust_short;
/* just another daily changing developer switch */
if (gfp->tune) {
gfc->sv_qnt.mask_adjust += gfp->tune_value_a;
gfc->sv_qnt.mask_adjust_short += gfp->tune_value_a;
}
if (gfp->VBR != vbr_off) { /* choose a min/max bitrate for VBR */
/* if the user didn't specify VBR_max_bitrate: */
cfg->vbr_min_bitrate_index = 1; /* default: allow 8 kbps (MPEG-2) or 32 kbps (MPEG-1) */
cfg->vbr_max_bitrate_index = 14; /* default: allow 160 kbps (MPEG-2) or 320 kbps (MPEG-1) */
if (cfg->samplerate_out < 16000)
cfg->vbr_max_bitrate_index = 8; /* default: allow 64 kbps (MPEG-2.5) */
if (gfp->VBR_min_bitrate_kbps) {
gfp->VBR_min_bitrate_kbps =
FindNearestBitrate(gfp->VBR_min_bitrate_kbps, cfg->version, cfg->samplerate_out);
cfg->vbr_min_bitrate_index =
BitrateIndex(gfp->VBR_min_bitrate_kbps, cfg->version, cfg->samplerate_out);
if (cfg->vbr_min_bitrate_index < 0)
return -1;
}
if (gfp->VBR_max_bitrate_kbps) {
gfp->VBR_max_bitrate_kbps =
FindNearestBitrate(gfp->VBR_max_bitrate_kbps, cfg->version, cfg->samplerate_out);
cfg->vbr_max_bitrate_index =
BitrateIndex(gfp->VBR_max_bitrate_kbps, cfg->version, cfg->samplerate_out);
if (cfg->vbr_max_bitrate_index < 0)
return -1;
}
gfp->VBR_min_bitrate_kbps = bitrate_table[cfg->version][cfg->vbr_min_bitrate_index];
gfp->VBR_max_bitrate_kbps = bitrate_table[cfg->version][cfg->vbr_max_bitrate_index];
gfp->VBR_mean_bitrate_kbps =
Min(bitrate_table[cfg->version][cfg->vbr_max_bitrate_index],
gfp->VBR_mean_bitrate_kbps);
gfp->VBR_mean_bitrate_kbps =
Max(bitrate_table[cfg->version][cfg->vbr_min_bitrate_index],
gfp->VBR_mean_bitrate_kbps);
}
cfg->preset = gfp->preset;
cfg->write_lame_tag = gfp->write_lame_tag;
cfg->vbr = gfp->VBR;
gfc->sv_qnt.substep_shaping = gfp->substep_shaping;
cfg->noise_shaping = gfp->noise_shaping;
cfg->subblock_gain = gfp->subblock_gain;
cfg->use_best_huffman = gfp->use_best_huffman;
cfg->avg_bitrate = gfp->brate;
cfg->vbr_avg_bitrate_kbps = gfp->VBR_mean_bitrate_kbps;
cfg->compression_ratio = gfp->compression_ratio;
/* initialize internal qval settings */
lame_init_qval(gfp);
/* automatic ATH adjustment on
*/
if (gfp->athaa_type < 0)
gfc->ATH->use_adjust = 3;
else
gfc->ATH->use_adjust = gfp->athaa_type;
/* initialize internal adaptive ATH settings -jd */
gfc->ATH->aa_sensitivity_p = pow(10.0, gfp->athaa_sensitivity / -10.0);
if (gfp->short_blocks == short_block_not_set) {
gfp->short_blocks = short_block_allowed;
}
/*Note Jan/2003: Many hardware decoders cannot handle short blocks in regular
stereo mode unless they are coupled (same type in both channels)
it is a rare event (1 frame per min. or so) that LAME would use
uncoupled short blocks, so lets turn them off until we decide
how to handle this. No other encoders allow uncoupled short blocks,
even though it is in the standard. */
/* rh 20040217: coupling makes no sense for mono and dual-mono streams
*/
if (gfp->short_blocks == short_block_allowed
&& (cfg->mode == JOINT_STEREO || cfg->mode == STEREO)) {
gfp->short_blocks = short_block_coupled;
}
cfg->short_blocks = gfp->short_blocks;
if (lame_get_quant_comp(gfp) < 0)
(void) lame_set_quant_comp(gfp, 1);
if (lame_get_quant_comp_short(gfp) < 0)
(void) lame_set_quant_comp_short(gfp, 0);
if (lame_get_msfix(gfp) < 0)
lame_set_msfix(gfp, 0);
/* select psychoacoustic model */
(void) lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 1);
if (gfp->ATHtype < 0)
gfp->ATHtype = 4;
if (gfp->ATHcurve < 0)
gfp->ATHcurve = 4;
if (gfp->interChRatio < 0)
gfp->interChRatio = 0;
if (gfp->useTemporal < 0)
gfp->useTemporal = 1; /* on by default */
cfg->interChRatio = gfp->interChRatio;
cfg->msfix = gfp->msfix;
cfg->ATH_offset_db = 0-gfp->ATH_lower_db;
cfg->ATH_offset_factor = powf(10.f, cfg->ATH_offset_db * 0.1f);
cfg->ATHcurve = gfp->ATHcurve;
cfg->ATHtype = gfp->ATHtype;
cfg->ATHonly = gfp->ATHonly;
cfg->ATHshort = gfp->ATHshort;
cfg->noATH = gfp->noATH;
cfg->quant_comp = gfp->quant_comp;
cfg->quant_comp_short = gfp->quant_comp_short;
cfg->use_temporal_masking_effect = gfp->useTemporal;
cfg->use_safe_joint_stereo = gfp->exp_nspsytune & 2;
{
cfg->adjust_bass_db = (gfp->exp_nspsytune >> 2) & 63;
if (cfg->adjust_bass_db >= 32.f)
cfg->adjust_bass_db -= 64.f;
cfg->adjust_bass_db *= 0.25f;
cfg->adjust_alto_db = (gfp->exp_nspsytune >> 8) & 63;
if (cfg->adjust_alto_db >= 32.f)
cfg->adjust_alto_db -= 64.f;
cfg->adjust_alto_db *= 0.25f;
cfg->adjust_treble_db = (gfp->exp_nspsytune >> 14) & 63;
if (cfg->adjust_treble_db >= 32.f)
cfg->adjust_treble_db -= 64.f;
cfg->adjust_treble_db *= 0.25f;
/* to be compatible with Naoki's original code, the next 6 bits
* define only the amount of changing treble for sfb21 */
cfg->adjust_sfb21_db = (gfp->exp_nspsytune >> 20) & 63;
if (cfg->adjust_sfb21_db >= 32.f)
cfg->adjust_sfb21_db -= 64.f;
cfg->adjust_sfb21_db *= 0.25f;
cfg->adjust_sfb21_db += cfg->adjust_treble_db;
}
/* Setting up the PCM input data transform matrix, to apply
* user defined re-scaling, and or two-to-one channel downmix.
*/
{
FLOAT m[2][2] = { {1.0f, 0.0f}, {0.0f, 1.0f} };
/* user selected scaling of the samples */
m[0][0] *= gfp->scale;
m[0][1] *= gfp->scale;
m[1][0] *= gfp->scale;
m[1][1] *= gfp->scale;
/* user selected scaling of the channel 0 (left) samples */
m[0][0] *= gfp->scale_left;
m[0][1] *= gfp->scale_left;
/* user selected scaling of the channel 1 (right) samples */
m[1][0] *= gfp->scale_right;
m[1][1] *= gfp->scale_right;
/* Downsample to Mono if 2 channels in and 1 channel out */
if (cfg->channels_in == 2 && cfg->channels_out == 1) {
m[0][0] = 0.5f * (m[0][0] + m[1][0]);
m[0][1] = 0.5f * (m[0][1] + m[1][1]);
m[1][0] = 0;
m[1][1] = 0;
}
cfg->pcm_transform[0][0] = m[0][0];
cfg->pcm_transform[0][1] = m[0][1];
cfg->pcm_transform[1][0] = m[1][0];
cfg->pcm_transform[1][1] = m[1][1];
}
/* padding method as described in
* "MPEG-Layer3 / Bitstream Syntax and Decoding"
* by Martin Sieler, Ralph Sperschneider
*
* note: there is no padding for the very first frame
*
* Robert Hegemann 2000-06-22
*/
gfc->sv_enc.slot_lag = gfc->sv_enc.frac_SpF = 0;
if (cfg->vbr == vbr_off)
gfc->sv_enc.slot_lag = gfc->sv_enc.frac_SpF
= ((cfg->version + 1) * 72000L * cfg->avg_bitrate) % cfg->samplerate_out;
(void) lame_init_bitstream(gfp);
iteration_init(gfc);
(void) psymodel_init(gfp);
cfg->buffer_constraint = get_max_frame_buffer_size_by_constraint(cfg, gfp->strict_ISO);
return 0;
}
void parse_args (int argc, char **argv, frame_info * frame, int *psy,
unsigned long *num_samples, char inPath[MAX_NAME_SIZE],
char outPath[MAX_NAME_SIZE], char **mot_file, char **icy_file)
{
FLOAT srate;
int brate;
frame_header *header = frame->header;
int err = 0, i = 0;
long samplerate = 0;
/* preset defaults */
inPath[0] = '\0';
outPath[0] = '\0';
header->lay = DFLT_LAY;
switch (DFLT_MOD) {
case 's':
header->mode = MPG_MD_STEREO;
header->mode_ext = 0;
break;
case 'd':
header->mode = MPG_MD_DUAL_CHANNEL;
header->mode_ext = 0;
break;
/* in j-stereo mode, no default header->mode_ext was defined, gave error..
now default = 2 added by MFC 14 Dec 1999. */
case 'j':
header->mode = MPG_MD_JOINT_STEREO;
header->mode_ext = 2;
break;
case 'm':
header->mode = MPG_MD_MONO;
header->mode_ext = 0;
break;
default:
fprintf (stderr, "%s: Bad mode dflt %c\n", programName, DFLT_MOD);
abort ();
}
*psy = DFLT_PSY;
if ((header->sampling_frequency =
SmpFrqIndex ((long) (1000 * DFLT_SFQ), &header->version)) < 0) {
fprintf (stderr, "%s: bad sfrq default %.2f\n", programName, DFLT_SFQ);
abort ();
}
header->bitrate_index = 14;
brate = 0;
switch (DFLT_EMP) {
case 'n':
header->emphasis = 0;
break;
case '5':
header->emphasis = 1;
break;
case 'c':
header->emphasis = 3;
break;
default:
fprintf (stderr, "%s: Bad emph dflt %c\n", programName, DFLT_EMP);
abort ();
}
header->copyright = 0;
header->original = 0;
header->error_protection = FALSE;
header->dab_extension = 0;
glopts.input_select = INPUT_SELECT_WAV;
/* process args */
while (++i < argc && err == 0) {
char c, *token, *arg, *nextArg;
int argUsed;
token = argv[i];
if (*token++ == '-') {
if (i + 1 < argc)
nextArg = argv[i + 1];
else
nextArg = "";
argUsed = 0;
if (!*token) {
/* The user wants to use stdin and/or stdout. */
if (inPath[0] == '\0')
strncpy (inPath, argv[i], MAX_NAME_SIZE);
else if (outPath[0] == '\0')
strncpy (outPath, argv[i], MAX_NAME_SIZE);
}
while ((c = *token++)) {
if (*token /* NumericQ(token) */ )
arg = token;
else
arg = nextArg;
switch (c) {
case 'm':
argUsed = 1;
if (*arg == 's') {
header->mode = MPG_MD_STEREO;
header->mode_ext = 0;
} else if (*arg == 'd') {
header->mode = MPG_MD_DUAL_CHANNEL;
header->mode_ext = 0;
} else if (*arg == 'j') {
header->mode = MPG_MD_JOINT_STEREO;
} else if (*arg == 'm') {
header->mode = MPG_MD_MONO;
header->mode_ext = 0;
} else {
fprintf (stderr, "%s: -m mode must be s/d/j/m not %s\n",
programName, arg);
err = 1;
}
break;
case 'y':
*psy = atoi (arg);
argUsed = 1;
break;
case 'L':
glopts.show_level = 1;
break;
case 's':
argUsed = 1;
srate = atof (arg);
/* samplerate = rint( 1000.0 * srate ); $A */
samplerate = (long) ((1000.0 * srate) + 0.5);
if ((header->sampling_frequency =
SmpFrqIndex ((long) samplerate, &header->version)) < 0)
err = 1;
break;
case 'j':
glopts.input_select = INPUT_SELECT_JACK;
break;
case 'b':
argUsed = 1;
brate = atoi (arg);
break;
case 'd':
argUsed = 1;
if (*arg == 'n')
header->emphasis = 0;
else if (*arg == '5')
header->emphasis = 1;
else if (*arg == 'c')
header->emphasis = 3;
else {
fprintf (stderr, "%s: -d emp must be n/5/c not %s\n", programName,
arg);
err = 1;
}
break;
case 'P':
argUsed = 1;
*mot_file = arg;
break;
case 'p':
argUsed = 1;
header->dab_length = atoi(arg);
break;
case 'c':
header->copyright = 1;
break;
case 'o':
header->original = 1;
break;
case 'e':
header->error_protection = TRUE;
break;
case 'r':
glopts.usepadbit = FALSE;
header->padding = 0;
break;
case 'q':
argUsed = 1;
glopts.quickmode = TRUE;
glopts.usepsy = TRUE;
glopts.quickcount = atoi (arg);
if (glopts.quickcount == 0) {
/* just don't use psy model */
glopts.usepsy = FALSE;
glopts.quickcount = FALSE;
}
break;
case 'a':
glopts.downmix = TRUE;
header->mode = MPG_MD_MONO;
header->mode_ext = 0;
break;
case 'x':
glopts.byteswap = TRUE;
break;
case 'v':
argUsed = 1;
glopts.vbr = TRUE;
glopts.vbrlevel = atof (arg);
glopts.usepadbit = FALSE; /* don't use padding for VBR */
header->padding = 0;
/* MFC Feb 2003: in VBR mode, joint stereo doesn't make
any sense at the moment, as there are no noisy subbands
according to bits_for_nonoise in vbr mode */
header->mode = MPG_MD_STEREO; /* force stereo mode */
header->mode_ext = 0;
break;
case 'V':
glopts.input_select = INPUT_SELECT_VLC;
break;
case 'W':
argUsed = 1;
*icy_file = arg;
break;
case 'l':
argUsed = 1;
glopts.athlevel = atof(arg);
break;
case 'h':
usage ();
break;
case 'g':
glopts.channelswap = TRUE;
break;
case 't':
argUsed = 1;
glopts.verbosity = atoi (arg);
break;
default:
fprintf (stderr, "%s: unrec option %c\n", programName, c);
err = 1;
break;
}
if (argUsed) {
if (arg == token)
token = ""; /* no more from token */
else
++i; /* skip arg we used */
arg = "";
argUsed = 0;
}
}
} else {
if (inPath[0] == '\0')
strcpy (inPath, argv[i]);
else if (outPath[0] == '\0')
strcpy (outPath, argv[i]);
else {
fprintf (stderr, "%s: excess arg %s\n", programName, argv[i]);
err = 1;
}
}
}
/* Always enable DAB mode */
header->error_protection = TRUE;
header->dab_extension = 2;
header->padding = 0;
glopts.dab = TRUE;
if (header->dab_extension) {
/* in 48 kHz */
/* if the bit rate per channel is less then 56 kbit/s, we have 2 scf-crc */
/* else we have 4 scf-crc */
/* in 24 kHz, we have 4 scf-crc, see main loop */
if (brate / (header->mode == MPG_MD_MONO ? 1 : 2) >= 56)
header->dab_extension = 4;
}
if (err)
usage (); /* If err has occured, then call usage() */
if (glopts.input_select != INPUT_SELECT_JACK && inPath[0] == '\0')
usage (); /* If not in jack-mode and no file specified, then call usage() */
if (outPath[0] == '\0') {
/* replace old extension with new one, 1992-08-19, 1995-06-12 shn */
new_ext (inPath, DFLT_EXT, outPath);
}
if (glopts.input_select == INPUT_SELECT_JACK) {
musicin.jack_name = inPath;
*num_samples = MAX_U_32_NUM;
#if defined(JACK_INPUT)
setup_jack(header, musicin.jack_name);
#else
fprintf(stderr, "JACK input not compiled in\n");
exit(1);
#endif
}
else if (glopts.input_select == INPUT_SELECT_WAV) {
if (!strcmp (inPath, "-")) {
musicin.wav_input = stdin; /* read from stdin */
*num_samples = MAX_U_32_NUM;
} else {
if ((musicin.wav_input = fopen (inPath, "rb")) == NULL) {
fprintf (stderr, "Could not find \"%s\".\n", inPath);
exit (1);
}
parse_input_file (musicin.wav_input, inPath, header, num_samples);
}
}
else if (glopts.input_select == INPUT_SELECT_VLC) {
if (samplerate == 0) {
fprintf (stderr, "Samplerate not specified\n");
exit (1);
}
*num_samples = MAX_U_32_NUM;
int channels = (header->mode == MPG_MD_MONO) ? 1 : 2;
#if defined(VLC_INPUT)
if (vlc_in_prepare(glopts.verbosity, samplerate, inPath, channels, *icy_file) != 0) {
fprintf(stderr, "VLC initialisation failed\n");
exit(1);
}
#else
fprintf(stderr, "VLC input not compiled in\n");
exit(1);
#endif
}
else {
fprintf(stderr, "INVALID INPUT\n");
exit(1);
}
/* check for a valid bitrate */
if (brate == 0)
brate = bitrate[header->version][10];
/* Check to see we have a sane value for the bitrate for this version */
if ((header->bitrate_index = BitrateIndex (brate, header->version)) < 0)
err = 1;
bs.zmq_framesize = 3 * brate;
/* All options are hunky dory, open the input audio file and
return to the main drag */
open_bit_stream_w (&bs, outPath, BUFFER_SIZE);
}
/********************************************************************
* initialize internal params based on data in gf
* (globalflags struct filled in by calling program)
*
********************************************************************/
void lame_init_params(lame_global_flags *gfp)
{
int i;
FLOAT compression_ratio;
memset(&bs, 0, sizeof(Bit_stream_struc));
memset(&l3_side,0x00,sizeof(III_side_info_t));
gfp->frameNum=0;
InitFormatBitStream();
if (gfp->num_channels==1) {
gfp->mode = MPG_MD_MONO;
}
gfp->stereo=2;
if (gfp->mode == MPG_MD_MONO) gfp->stereo=1;
#ifdef BRHIST
if (gfp->silent) {
disp_brhist=0; /* turn of VBR historgram */
}
if (!gfp->VBR) {
disp_brhist=0; /* turn of VBR historgram */
}
#endif
/* set the output sampling rate, and resample options if necessary
samplerate = input sample rate
resamplerate = ouput sample rate
*/
if (gfp->out_samplerate==0) {
/* user did not specify output sample rate */
gfp->out_samplerate=gfp->in_samplerate; /* default */
/* if resamplerate is not valid, find a valid value */
if (gfp->out_samplerate>=48000) gfp->out_samplerate=48000;
else if (gfp->out_samplerate>=44100) gfp->out_samplerate=44100;
else if (gfp->out_samplerate>=32000) gfp->out_samplerate=32000;
else if (gfp->out_samplerate>=24000) gfp->out_samplerate=24000;
else if (gfp->out_samplerate>=22050) gfp->out_samplerate=22050;
else gfp->out_samplerate=16000;
if (gfp->brate>0) {
/* check if user specified bitrate requires downsampling */
compression_ratio = gfp->out_samplerate*16*gfp->stereo/(1000.0*gfp->brate);
if (!gfp->VBR && compression_ratio > 13 ) {
/* automatic downsample, if possible */
gfp->out_samplerate = (10*1000.0*gfp->brate)/(16*gfp->stereo);
if (gfp->out_samplerate<=16000) gfp->out_samplerate=16000;
else if (gfp->out_samplerate<=22050) gfp->out_samplerate=22050;
else if (gfp->out_samplerate<=24000) gfp->out_samplerate=24000;
else if (gfp->out_samplerate<=32000) gfp->out_samplerate=32000;
else if (gfp->out_samplerate<=44100) gfp->out_samplerate=44100;
else gfp->out_samplerate=48000;
}
}
}
gfp->mode_gr = (gfp->out_samplerate <= 24000) ? 1 : 2; /* mode_gr = 2 */
gfp->encoder_delay = ENCDELAY;
gfp->framesize = gfp->mode_gr*576;
if (gfp->brate==0) { /* user didn't specify a bitrate, use default */
gfp->brate=128;
if (gfp->mode_gr==1) gfp->brate=64;
}
gfp->resample_ratio=1;
if (gfp->out_samplerate != gfp->in_samplerate) gfp->resample_ratio = (FLOAT)gfp->in_samplerate/(FLOAT)gfp->out_samplerate;
/* estimate total frames. must be done after setting sampling rate so
* we know the framesize. */
gfp->totalframes=0;
gfp->totalframes = 2+ gfp->num_samples/(gfp->resample_ratio*gfp->framesize);
/* 44.1kHz at 56kbs/channel: compression factor of 12.6
44.1kHz at 64kbs/channel: compression factor of 11.025
44.1kHz at 80kbs/channel: compression factor of 8.82
22.05kHz at 24kbs: 14.7
22.05kHz at 32kbs: 11.025
22.05kHz at 40kbs: 8.82
16kHz at 16kbs: 16.0
16kHz at 24kbs: 10.7
compression_ratio
11 .70?
12 sox resample .66
14.7 sox resample .45
*/
if (gfp->brate >= 320) gfp->VBR=0; /* dont bother with VBR at 320kbs */
compression_ratio = gfp->out_samplerate*16*gfp->stereo/(1000.0*gfp->brate);
/* for VBR, take a guess at the compression_ratio */
/* VBR_q compression like
0 4.4 320kbs
1 5.4 256kbs
3 7.4 192kbs
4 8.8 160kbs
6 10.4 128kbs
*/
if (gfp->VBR && compression_ratio>11) {
compression_ratio = 4.4 + gfp->VBR_q;
}
/* At higher quality (lower compression) use STEREO instead of JSTEREO.
* (unless the user explicitly specified a mode ) */
if ( (!gfp->mode_fixed) && (gfp->mode !=MPG_MD_MONO)) {
if (compression_ratio < 9 ) {
gfp->mode = MPG_MD_STEREO;
}
}
/****************************************************************/
/* if a filter has not been enabled, see if we should add one: */
/****************************************************************/
if (gfp->lowpassfreq == 0) {
/* If the user has not selected their own filter, add a lowpass
* filter based on the compression ratio. Formula based on
44.1 /160 4.4x
44.1 /128 5.5x keep all bands
44.1 /96kbs 7.3x keep band 28
44.1 /80kbs 8.8x keep band 25
44.1khz/64kbs 11x keep band 21 22?
16khz/24kbs 10.7x keep band 21
22kHz/32kbs 11x keep band ?
22kHz/24kbs 14.7x keep band 16
16 16 16x keep band 14
*/
/* Should we use some lowpass filters? */
int band = 1+floor(.5 + 14-18*log(compression_ratio/16.0));
if (band < 31) {
gfp->lowpass1 = band/31.0;
gfp->lowpass2 = band/31.0;
}
}
/****************************************************************/
/* apply user driven filters*/
/****************************************************************/
if ( gfp->highpassfreq > 0 ) {
gfp->highpass1 = 2.0*gfp->highpassfreq/gfp->out_samplerate; /* will always be >=0 */
if ( gfp->highpasswidth >= 0 ) {
gfp->highpass2 = 2.0*(gfp->highpassfreq+gfp->highpasswidth)/gfp->out_samplerate;
} else {
/* 15% above on default */
/* gfp->highpass2 = 1.15*2.0*gfp->highpassfreq/gfp->out_samplerate; */
gfp->highpass2 = 1.00*2.0*gfp->highpassfreq/gfp->out_samplerate;
}
gfp->highpass1 = Min( 1, gfp->highpass1 );
gfp->highpass2 = Min( 1, gfp->highpass2 );
}
if ( gfp->lowpassfreq > 0 ) {
gfp->lowpass2 = 2.0*gfp->lowpassfreq/gfp->out_samplerate; /* will always be >=0 */
if ( gfp->lowpasswidth >= 0 ) {
gfp->lowpass1 = 2.0*(gfp->lowpassfreq-gfp->lowpasswidth)/gfp->out_samplerate;
if ( gfp->lowpass1 < 0 ) { /* has to be >= 0 */
gfp->lowpass1 = 0;
}
} else {
/* 15% below on default */
/* gfp->lowpass1 = 0.85*2.0*gfp->lowpassfreq/gfp->out_samplerate; */
gfp->lowpass1 = 1.00*2.0*gfp->lowpassfreq/gfp->out_samplerate;
}
gfp->lowpass1 = Min( 1, gfp->lowpass1 );
gfp->lowpass2 = Min( 1, gfp->lowpass2 );
}
/***************************************************************/
/* compute info needed for polyphase filter */
/***************************************************************/
if (gfp->filter_type==0) {
int band,maxband,minband;
FLOAT8 amp,freq;
if (gfp->lowpass1 > 0) {
minband=999;
maxband=-1;
for (band=0; band <=31 ; ++band) {
freq = band/31.0;
amp = 1;
/* this band and above will be zeroed: */
if (freq >= gfp->lowpass2) {
gfp->lowpass_band= Min(gfp->lowpass_band,band);
amp=0;
}
if (gfp->lowpass1 < freq && freq < gfp->lowpass2) {
minband = Min(minband,band);
maxband = Max(maxband,band);
amp = cos((PI/2)*(gfp->lowpass1-freq)/(gfp->lowpass2-gfp->lowpass1));
}
/* printf("lowpass band=%i amp=%f \n",band,amp);*/
}
/* compute the *actual* transition band implemented by the polyphase filter */
if (minband==999) gfp->lowpass1 = (gfp->lowpass_band-.75)/31.0;
else gfp->lowpass1 = (minband-.75)/31.0;
gfp->lowpass2 = gfp->lowpass_band/31.0;
}
/* make sure highpass filter is within 90% of whan the effective highpass
* frequency will be */
if (gfp->highpass2 > 0)
if (gfp->highpass2 < .9*(.75/31.0) ) {
gfp->highpass1=0; gfp->highpass2=0;
fprintf(stderr,"Warning: highpass filter disabled. highpass frequency to small\n");
}
if (gfp->highpass2 > 0) {
minband=999;
maxband=-1;
for (band=0; band <=31; ++band) {
freq = band/31.0;
amp = 1;
/* this band and below will be zereod */
if (freq <= gfp->highpass1) {
gfp->highpass_band = Max(gfp->highpass_band,band);
amp=0;
}
if (gfp->highpass1 < freq && freq < gfp->highpass2) {
minband = Min(minband,band);
maxband = Max(maxband,band);
amp = cos((PI/2)*(gfp->highpass2-freq)/(gfp->highpass2-gfp->highpass1));
}
/* printf("highpass band=%i amp=%f \n",band,amp);*/
}
/* compute the *actual* transition band implemented by the polyphase filter */
gfp->highpass1 = gfp->highpass_band/31.0;
if (maxband==-1) gfp->highpass2 = (gfp->highpass_band+.75)/31.0;
else gfp->highpass2 = (maxband+.75)/31.0;
}
/*
printf("lowpass band with amp=0: %i \n",gfp->lowpass_band);
printf("highpass band with amp=0: %i \n",gfp->highpass_band);
*/
}
/***************************************************************/
/* compute info needed for FIR filter */
/***************************************************************/
if (gfp->filter_type==1) {
}
gfp->mode_ext=MPG_MD_LR_LR;
gfp->stereo = (gfp->mode == MPG_MD_MONO) ? 1 : 2;
gfp->samplerate_index = SmpFrqIndex((long)gfp->out_samplerate, &gfp->version);
if( gfp->samplerate_index < 0) {
display_bitrates(stderr);
exit(1);
}
if( (gfp->bitrate_index = BitrateIndex(gfp->brate, gfp->version,gfp->out_samplerate)) < 0) {
display_bitrates(stderr);
exit(1);
}
/* choose a min/max bitrate for VBR */
if (gfp->VBR) {
/* if the user didn't specify VBR_max_bitrate: */
if (0==gfp->VBR_max_bitrate_kbps) {
/* default max bitrate is 256kbs */
/* we do not normally allow 320bps frams with VBR, unless: */
gfp->VBR_max_bitrate=13; /* default: allow 256kbs */
if (gfp->VBR_min_bitrate_kbps>=256) gfp->VBR_max_bitrate=14;
if (gfp->VBR_q == 0) gfp->VBR_max_bitrate=14; /* allow 320kbs */
if (gfp->VBR_q >= 4) gfp->VBR_max_bitrate=12; /* max = 224kbs */
if (gfp->VBR_q >= 8) gfp->VBR_max_bitrate=9; /* low quality, max = 128kbs */
}else{
if( (gfp->VBR_max_bitrate = BitrateIndex(gfp->VBR_max_bitrate_kbps, gfp->version,gfp->out_samplerate)) < 0) {
display_bitrates(stderr);
exit(1);
}
}
if (0==gfp->VBR_min_bitrate_kbps) {
gfp->VBR_min_bitrate=1; /* 32 kbps */
}else{
if( (gfp->VBR_min_bitrate = BitrateIndex(gfp->VBR_min_bitrate_kbps, gfp->version,gfp->out_samplerate)) < 0) {
display_bitrates(stderr);
exit(1);
}
}
}
if (gfp->VBR) gfp->quality=Min(gfp->quality,2); /* always use quality <=2 with VBR */
/* dont allow forced mid/side stereo for mono output */
if (gfp->mode == MPG_MD_MONO) gfp->force_ms=0;
/* Do not write VBR tag if VBR flag is not specified */
if (gfp->VBR==0) gfp->bWriteVbrTag=0;
/* some file options not allowed if output is: not specified or stdout */
if (gfp->outPath!=NULL && gfp->outPath[0]=='-' ) {
gfp->bWriteVbrTag=0; /* turn off VBR tag */
}
if (gfp->outPath==NULL || gfp->outPath[0]=='-' ) {
id3tag.used=0; /* turn of id3 tagging */
}
if (gfp->gtkflag) {
gfp->bWriteVbrTag=0; /* disable Xing VBR tag */
}
init_bit_stream_w(&bs);
/* set internal feature flags. USER should not access these since
* some combinations will produce strange results */
/* no psymodel, no noise shaping */
if (gfp->quality==9) {
gfp->filter_type=0;
gfp->psymodel=0;
gfp->quantization=0;
gfp->noise_shaping=0;
gfp->noise_shaping_stop=0;
gfp->use_best_huffman=0;
}
if (gfp->quality==8) gfp->quality=7;
/* use psymodel (for short block and m/s switching), but no noise shapping */
if (gfp->quality==7) {
gfp->filter_type=0;
gfp->psymodel=1;
gfp->quantization=0;
gfp->noise_shaping=0;
gfp->noise_shaping_stop=0;
gfp->use_best_huffman=0;
}
if (gfp->quality==6) gfp->quality=5;
if (gfp->quality==5) {
/* the default */
gfp->filter_type=0;
gfp->psymodel=1;
gfp->quantization=0;
gfp->noise_shaping=1;
gfp->noise_shaping_stop=0;
gfp->use_best_huffman=0;
}
if (gfp->quality==4) gfp->quality=2;
if (gfp->quality==3) gfp->quality=2;
if (gfp->quality==2) {
gfp->filter_type=0;
gfp->psymodel=1;
gfp->quantization=1;
gfp->noise_shaping=1;
gfp->noise_shaping_stop=0;
gfp->use_best_huffman=1;
}
if (gfp->quality==1) {
gfp->filter_type=0;
gfp->psymodel=1;
gfp->quantization=1;
gfp->noise_shaping=1;
gfp->noise_shaping_stop=1;
gfp->use_best_huffman=1;
}
if (gfp->quality==0) {
/* 0..1 quality */
gfp->filter_type=1; /* not yet coded */
gfp->psymodel=1;
gfp->quantization=1;
gfp->noise_shaping=3; /* not yet coded */
gfp->noise_shaping_stop=2; /* not yet coded */
gfp->use_best_huffman=2; /* not yet coded */
exit(-99);
}
for (i = 0; i < SBMAX_l + 1; i++) {
scalefac_band.l[i] =
sfBandIndex[gfp->samplerate_index + (gfp->version * 3)].l[i];
}
for (i = 0; i < SBMAX_s + 1; i++) {
scalefac_band.s[i] =
sfBandIndex[gfp->samplerate_index + (gfp->version * 3)].s[i];
}
if (gfp->bWriteVbrTag)
{
/* Write initial VBR Header to bitstream */
InitVbrTag(&bs,1-gfp->version,gfp->mode,gfp->samplerate_index);
}
#ifdef HAVEGTK
gtkflag=gfp->gtkflag;
#endif
#ifdef BRHIST
if (gfp->VBR) {
if (disp_brhist)
brhist_init(gfp,1, 14);
} else
disp_brhist = 0;
#endif
return;
}
