/************************************************************************
* allocate bits among 2 channels based on PE
* mt 6/99
* bugfixes rh 8/01: often allocated more than the allowed 4095 bits
************************************************************************/
int
on_pe(lame_internal_flags * gfc, const FLOAT pe[][2], int targ_bits[2], int mean_bits, int gr, int cbr)
{
SessionConfig_t const *const cfg = &gfc->cfg;
int extra_bits = 0, tbits, bits;
int add_bits[2] = {0, 0};
int max_bits; /* maximum allowed bits for this granule */
int ch;
/* allocate targ_bits for granule */
ResvMaxBits(gfc, mean_bits, &tbits, &extra_bits, cbr);
max_bits = tbits + extra_bits;
if (max_bits > MAX_BITS_PER_GRANULE) /* hard limit per granule */
max_bits = MAX_BITS_PER_GRANULE;
for (bits = 0, ch = 0; ch < cfg->channels_out; ++ch) {
/******************************************************************
* allocate bits for each channel
******************************************************************/
targ_bits[ch] = Min(MAX_BITS_PER_CHANNEL, tbits / cfg->channels_out);
add_bits[ch] = targ_bits[ch] * pe[gr][ch] / 700.0 - targ_bits[ch];
/* at most increase bits by 1.5*average */
if (add_bits[ch] > mean_bits * 3 / 4)
add_bits[ch] = mean_bits * 3 / 4;
if (add_bits[ch] < 0)
add_bits[ch] = 0;
if (add_bits[ch] + targ_bits[ch] > MAX_BITS_PER_CHANNEL)
add_bits[ch] = Max(0, MAX_BITS_PER_CHANNEL - targ_bits[ch]);
bits += add_bits[ch];
}
if (bits > extra_bits && bits > 0) {
for (ch = 0; ch < cfg->channels_out; ++ch) {
add_bits[ch] = extra_bits * add_bits[ch] / bits;
}
}
for (ch = 0; ch < cfg->channels_out; ++ch) {
targ_bits[ch] += add_bits[ch];
extra_bits -= add_bits[ch];
}
for (bits = 0, ch = 0; ch < cfg->channels_out; ++ch) {
bits += targ_bits[ch];
}
if (bits > MAX_BITS_PER_GRANULE) {
int sum = 0;
for (ch = 0; ch < cfg->channels_out; ++ch) {
targ_bits[ch] *= MAX_BITS_PER_GRANULE;
targ_bits[ch] /= bits;
sum += targ_bits[ch];
}
assert(sum <= MAX_BITS_PER_GRANULE);
}
return max_bits;
}
/************************************************************************
* allocate bits among 2 channels based on PE
* mt 6/99
* bugfixes rh 8/01: often allocated more than the allowed 4095 bits
************************************************************************/
int on_pe( lame_global_flags *gfp, FLOAT8 pe[][2], III_side_info_t *l3_side,
int targ_bits[2], int mean_bits, int gr )
{
lame_internal_flags * gfc = gfp->internal_flags;
gr_info * cod_info;
int extra_bits, tbits, bits;
int add_bits[2];
int max_bits; /* maximum allowed bits for this granule */
int ch;
/* allocate targ_bits for granule */
ResvMaxBits( gfp, mean_bits, &tbits, &extra_bits );
max_bits = tbits + extra_bits;
mean_bits /= gfc->channels_out;
if (max_bits > MAX_BITS) /* hard limit per granule */
max_bits = MAX_BITS;
for ( bits = 0, ch = 0; ch < gfc->channels_out; ++ch ) {
/******************************************************************
* allocate bits for each channel
******************************************************************/
cod_info = &l3_side->tt[gr][ch];
targ_bits[ch] = Min( MAX_BITS, tbits/gfc->channels_out );
if (gfc->nsPsy.use) {
add_bits[ch] = targ_bits[ch] * pe[gr][ch] / 700.0 - targ_bits[ch];
}
else {
add_bits[ch] = (pe[gr][ch]-750) / 1.4;
/* short blocks us a little extra, no matter what the pe */
if ( cod_info->block_type == SHORT_TYPE ) {
if (add_bits[ch] < mean_bits/2)
add_bits[ch] = mean_bits/2;
}
}
/* at most increase bits by 1.5*average */
if (add_bits[ch] > mean_bits*3/2)
add_bits[ch] = mean_bits*3/2;
if (add_bits[ch] < 0)
add_bits[ch] = 0;
if (add_bits[ch]+targ_bits[ch] > MAX_BITS)
add_bits[ch] = Max( 0, MAX_BITS-targ_bits[ch] );
bits += add_bits[ch];
}
if (bits > extra_bits) {
for ( ch = 0; ch < gfc->channels_out; ++ch ) {
add_bits[ch] = extra_bits * add_bits[ch] / bits;
}
}
for ( ch = 0; ch < gfc->channels_out; ++ch ) {
targ_bits[ch] += add_bits[ch];
extra_bits -= add_bits[ch];
assert( targ_bits[ch] <= MAX_BITS );
}
assert( max_bits <= MAX_BITS );
return max_bits;
}
/*
* L3_iteration_loop:
* ------------------
*/
void L3_iteration_loop(struct config_t *cfg, double pe[][2],
long mdct_freq_org[2][2][samp_per_frame2],
L3_psy_ratio_t *ratio,
L3_side_info_t *side_info,
int l3_enc[2][2][samp_per_frame2],
int mean_bits,
L3_scalefac_t *scalefactor)
{
L3_psy_xmin_t l3_xmin;
gr_info *cod_info;
int *main_data_begin;
int max_bits;
int ch, gr, i;
static int firstcall = 1;
int *ix;
main_data_begin = &side_info->main_data_begin;
if ( firstcall )
{
*main_data_begin = 0;
firstcall=0;
}
scalefac_band_long = &sfBandIndex[cfg->mpeg.samplerate_index + (cfg->mpeg.type * 3)].l[0];
for(ch=cfg->wave.channels; ch--; )
{
for(gr=0; gr<2; gr++)
{
/* setup pointers */
ix = l3_enc[gr][ch];
xr = mdct_freq_org[gr][ch];
/* Precalculate the square, abs, and maximum,
* for use later on.
*/
for (i=samp_per_frame2, xrmax=0; i--;)
{
xrsq[i] = mulsr(xr[i],xr[i]);
xrabs[i] = labs(xr[i]);
if(xrabs[i]>xrmax)
xrmax=xrabs[i];
}
cod_info = (gr_info *) &(side_info->gr[gr].ch[ch]);
cod_info->sfb_lmax = SFB_LMAX - 1; /* gr_deco */
calc_xmin(ratio, cod_info, &l3_xmin, gr, ch );
calc_scfsi(side_info,&l3_xmin,ch,gr);
/* calculation of number of available bit( per granule ) */
max_bits = ResvMaxBits(cfg, side_info,&pe[gr][ch],mean_bits);
/* reset of iteration variables */
memset(scalefactor->l[gr][ch],0,22);
memset(scalefactor->s[gr][ch],0,14);
for ( i=4; i--; )
cod_info->slen[i] = 0;
cod_info->part2_3_length = 0;
cod_info->big_values = 0;
cod_info->count1 = 0;
cod_info->scalefac_compress = 0;
cod_info->table_select[0] = 0;
cod_info->table_select[1] = 0;
cod_info->table_select[2] = 0;
cod_info->region0_count = 0;
cod_info->region1_count = 0;
cod_info->part2_length = 0;
cod_info->preflag = 0;
cod_info->scalefac_scale = 0;
cod_info->count1table_select= 0;
/* all spectral values zero ? */
if(xrmax)
cod_info->part2_3_length = outer_loop(max_bits,&l3_xmin,ix,
scalefactor,
gr,ch,side_info );
ResvAdjust(cfg, cod_info, side_info, mean_bits );
cod_info->global_gain = cod_info->quantizerStepSize+210;
} /* for gr */
} /* for ch */
ResvFrameEnd(cfg, side_info,mean_bits);
}
