📄 quantize-pvt.c
字号:
/*************************************************************************/
/* scale_bitcount */
/*************************************************************************/
/* Also calculates the number of bits necessary to code the scalefactors. */
int scale_bitcount( III_scalefac_t *scalefac, gr_info *cod_info)
{
int i, k, sfb, max_slen1 = 0, max_slen2 = 0, /*a, b, */ ep = 2;
static int slen1[16] = { 1, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8,16,16 };
static int slen2[16] = { 1, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8 };
static int slen1_tab[16] = {0,
18, 36, 54, 54, 36, 54, 72, 54, 72, 90, 72, 90,108,108,126
};
static int slen2_tab[16] = {0,
10, 20, 30, 33, 21, 31, 41, 32, 42, 52, 43, 53, 63, 64, 74
};
int *tab;
if ( cod_info->block_type == SHORT_TYPE )
{
tab = slen1_tab;
/* a = 18; b = 18; */
for ( i = 0; i < 3; i++ )
{
for ( sfb = 0; sfb < 6; sfb++ )
if (scalefac->s[sfb][i] > max_slen1 )
max_slen1 = scalefac->s[sfb][i];
for (sfb = 6; sfb < SBPSY_s; sfb++ )
if ( scalefac->s[sfb][i] > max_slen2 )
max_slen2 = scalefac->s[sfb][i];
}
}
else
{ /* block_type == 1,2,or 3 */
tab = slen2_tab;
/* a = 11; b = 10; */
for ( sfb = 0; sfb < 11; sfb++ )
if ( scalefac->l[sfb] > max_slen1 )
max_slen1 = scalefac->l[sfb];
if (!cod_info->preflag) {
for ( sfb = 11; sfb < SBPSY_l; sfb++ )
if (scalefac->l[sfb] < pretab[sfb])
break;
if (sfb == SBPSY_l) {
cod_info->preflag = 1;
for ( sfb = 11; sfb < SBPSY_l; sfb++ )
scalefac->l[sfb] -= pretab[sfb];
}
}
for ( sfb = 11; sfb < SBPSY_l; sfb++ )
if ( scalefac->l[sfb] > max_slen2 )
max_slen2 = scalefac->l[sfb];
}
/* from Takehiro TOMINAGA <tominaga@isoternet.org> 10/99
* loop over *all* posible values of scalefac_compress to find the
* one which uses the smallest number of bits. ISO would stop
* at first valid index */
cod_info->part2_length = LARGE_BITS;
for ( k = 0; k < 16; k++ )
{
if ( (max_slen1 < slen1[k]) && (max_slen2 < slen2[k]) &&
((int)cod_info->part2_length > tab[k])) {
cod_info->part2_length=tab[k];
cod_info->scalefac_compress=k;
ep=0; /* we found a suitable scalefac_compress */
}
}
return ep;
}
/*
table of largest scalefactors (number of bits) for MPEG2
*/
/*
static unsigned max_sfac_tab[6][4] =
{
{4, 4, 3, 3},
{4, 4, 3, 0},
{3, 2, 0, 0},
{4, 5, 5, 0},
{3, 3, 3, 0},
{2, 2, 0, 0}
};
*/
/*
table of largest scalefactor values for MPEG2
*/
static unsigned max_range_sfac_tab[6][4] =
{
{ 15, 15, 7, 7},
{ 15, 15, 7, 0},
{ 7, 3, 0, 0},
{ 15, 31, 31, 0},
{ 7, 7, 7, 0},
{ 3, 3, 0, 0}
};
/*************************************************************************/
/* scale_bitcount_lsf */
/*************************************************************************/
/* Also counts the number of bits to encode the scalefacs but for MPEG 2 */
/* Lower sampling frequencies (24, 22.05 and 16 kHz.) */
/* This is reverse-engineered from section 2.4.3.2 of the MPEG2 IS, */
/* "Audio Decoding Layer III" */
int scale_bitcount_lsf(III_scalefac_t *scalefac, gr_info *cod_info)
{
int table_number, row_in_table, partition, nr_sfb, window, over;
int i, sfb, max_sfac[ 4 ];
unsigned *partition_table;
/*
Set partition table. Note that should try to use table one,
but do not yet...
*/
if ( cod_info->preflag )
table_number = 2;
else
table_number = 0;
for ( i = 0; i < 4; i++ )
max_sfac[i] = 0;
if ( cod_info->block_type == SHORT_TYPE )
{
row_in_table = 1;
partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
for ( sfb = 0, partition = 0; partition < 4; partition++ )
{
nr_sfb = partition_table[ partition ] / 3;
for ( i = 0; i < nr_sfb; i++, sfb++ )
for ( window = 0; window < 3; window++ )
if ( scalefac->s[sfb][window] > max_sfac[partition] )
max_sfac[partition] = scalefac->s[sfb][window];
}
}
else
{
row_in_table = 0;
partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
for ( sfb = 0, partition = 0; partition < 4; partition++ )
{
nr_sfb = partition_table[ partition ];
for ( i = 0; i < nr_sfb; i++, sfb++ )
if ( scalefac->l[sfb] > max_sfac[partition] )
max_sfac[partition] = scalefac->l[sfb];
}
}
for ( over = 0, partition = 0; partition < 4; partition++ )
{
if ( max_sfac[partition] > (int)max_range_sfac_tab[table_number][partition] )
over++;
}
if ( !over )
{
/*
Since no bands have been over-amplified, we can set scalefac_compress
and slen[] for the formatter
*/
static int log2tab[] = { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
unsigned slen1, slen2, slen3, slen4;
cod_info->sfb_partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
for ( partition = 0; partition < 4; partition++ )
cod_info->slen[partition] = log2tab[max_sfac[partition]];
/* set scalefac_compress */
slen1 = cod_info->slen[ 0 ];
slen2 = cod_info->slen[ 1 ];
slen3 = cod_info->slen[ 2 ];
slen4 = cod_info->slen[ 3 ];
switch ( table_number )
{
case 0:
cod_info->scalefac_compress = (((slen1 * 5) + slen2) << 4)
+ (slen3 << 2)
+ slen4;
break;
case 1:
cod_info->scalefac_compress = 400
+ (((slen1 * 5) + slen2) << 2)
+ slen3;
break;
case 2:
cod_info->scalefac_compress = 500 + (slen1 * 3) + slen2;
break;
default:
fprintf( stderr, "intensity stereo not implemented yet\n" );
exit( EXIT_FAILURE );
break;
}
}
#ifdef DEBUG
if ( over )
printf( "---WARNING !! Amplification of some bands over limits\n" );
#endif
if (!over) {
assert( cod_info->sfb_partition_table );
cod_info->part2_length=0;
for ( partition = 0; partition < 4; partition++ )
cod_info->part2_length += cod_info->slen[partition] * cod_info->sfb_partition_table[partition];
}
return over;
}
/*************************************************************************/
/* calc_xmin */
/*************************************************************************/
/*
Calculate the allowed distortion for each scalefactor band,
as determined by the psychoacoustic model.
xmin(sb) = ratio(sb) * en(sb) / bw(sb)
returns number of sfb's with energy > ATH
*/
int calc_xmin( lame_global_flags *gfp,FLOAT8 xr[576], III_psy_ratio *ratio,
gr_info *cod_info, III_psy_xmin *l3_xmin)
{
int start, end, bw,l, b, ath_over=0;
u_int sfb;
FLOAT8 en0, xmin, ener;
if (gfp->ATHonly) {
for ( sfb = cod_info->sfb_smax; sfb < SBPSY_s; sfb++ )
for ( b = 0; b < 3; b++ )
l3_xmin->s[sfb][b]=ATH_s[sfb];
for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
l3_xmin->l[sfb]=ATH_l[sfb];
}else{
for ( sfb = cod_info->sfb_smax; sfb < SBPSY_s; sfb++ ) {
start = scalefac_band.s[ sfb ];
end = scalefac_band.s[ sfb + 1 ];
bw = end - start;
for ( b = 0; b < 3; b++ ) {
for (en0 = 0.0, l = start; l < end; l++) {
ener = xr[l * 3 + b];
ener = ener * ener;
en0 += ener;
}
en0 /= bw;
xmin = ratio->en.s[sfb][b];
if (xmin > 0.0)
xmin = en0 * ratio->thm.s[sfb][b] * masking_lower / xmin;
#ifdef RH_ATH
/* do not mix up ATH masking with GPSYCHO thresholds
*/
l3_xmin->s[sfb][b] = Max(1e-20, xmin);
#else
l3_xmin->s[sfb][b] = Max(ATH_s[sfb], xmin);
#endif
if (en0 > ATH_s[sfb]) ath_over++;
}
}
for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ ){
start = scalefac_band.l[ sfb ];
end = scalefac_band.l[ sfb+1 ];
bw = end - start;
for (en0 = 0.0, l = start; l < end; l++ ) {
ener = xr[l] * xr[l];
en0 += ener;
}
en0 /= bw;
xmin = ratio->en.l[sfb];
if (xmin > 0.0)
xmin = en0 * ratio->thm.l[sfb] * masking_lower / xmin;
#ifdef RH_ATH
/* do not mix up ATH masking with GPSYCHO thresholds
*/
l3_xmin->l[sfb]=Max(1e-20, xmin);
#else
l3_xmin->l[sfb]=Max(ATH_l[sfb], xmin);
#endif
if (en0 > ATH_l[sfb]) ath_over++;
}
}
return ath_over;
}
/*************************************************************************/
/* loop_break */
/*************************************************************************/
/* Function: Returns zero if there is a scalefac which has not been
amplified. Otherwise it returns one.
*/
int loop_break( III_scalefac_t *scalefac, gr_info *cod_info)
{
int i;
u_int sfb;
for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
if ( scalefac->l[sfb] == 0 )
return 0;
for ( sfb = cod_info->sfb_smax; sfb < SBPSY_s; sfb++ )
for ( i = 0; i < 3; i++ )
if ( scalefac->s[sfb][i] == 0 )
return 0;
return 1;
}
/*
----------------------------------------------------------------------
if someone wants to try to find a faster step search function,
here is some code which gives a lower bound for the step size:
for (max_xrspow = 0, i = 0; i < 576; ++i)
{
max_xrspow = Max(max_xrspow, xrspow[i]);
}
lowerbound = 210+log10(max_xrspow/IXMAX_VAL)/(0.1875*LOG2);
Robert.Hegemann@gmx.de
----------------------------------------------------------------------
*/
typedef enum {
BINSEARCH_NONE,
BINSEARCH_UP,
BINSEARCH_DOWN
} binsearchDirection_t;
/*-------------------------------------------------------------------------*/
int
bin_search_StepSize2 (lame_global_flags *gfp,int desired_rate, int start, int *ix,
FLOAT8 xrspow[576], gr_info *cod_info)
/*-------------------------------------------------------------------------*/
{
static int CurrentStep = 4;
int nBits;
int flag_GoneOver = 0;
int StepSize = start;
binsearchDirection_t Direction = BINSEARCH_NONE;
do
{
cod_info->global_gain = StepSize;
nBits = count_bits(gfp,ix, xrspow, cod_info);
if (CurrentStep == 1 )
{
break; /* nothing to adjust anymore */
}
if (flag_GoneOver)
{
CurrentStep /= 2;
}
if (nBits > desired_rate) /* increase Quantize_StepSize */
{
if (Direction == BINSEARCH_DOWN && !flag_GoneOver)
{
flag_GoneOver = 1;
CurrentStep /= 2; /* late adjust */
}
Direction = BINSEARCH_UP;
StepSize += CurrentStep;
if (StepSize > 255) break;
}
else if (nBits < desired_rate)
{
if (Direction == BINSEARCH_UP && !flag_GoneOver)
{
flag_GoneOver = 1;
CurrentStep /= 2; /* late adjust */
}
Direction = BINSEARCH_DOWN;
StepSize -= CurrentStep;
if (StepSize < 0) break;
}
else break; /* nBits == desired_rate;; most unlikely to happen.*/
} while (1); /* For-ever, break is adjusted. */
CurrentStep = abs(start - StepSize);
if (CurrentStep >= 4) {
CurrentStep = 4;
} else {
CurrentStep = 2;
}
return nBits;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -