1075 lines
33 KiB
C
1075 lines
33 KiB
C
/*
|
|
* quantize_pvt source file
|
|
*
|
|
* Copyright (c) 1999-2002 Takehiro Tominaga
|
|
* Copyright (c) 2000-2012 Robert Hegemann
|
|
* Copyright (c) 2001 Naoki Shibata
|
|
* Copyright (c) 2002-2005 Gabriel Bouvigne
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/* $Id: quantize_pvt.c,v 1.175 2017/09/06 15:07:30 robert Exp $ */
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
|
|
#include "lame.h"
|
|
#include "machine.h"
|
|
#include "encoder.h"
|
|
#include "util.h"
|
|
#include "quantize_pvt.h"
|
|
#include "reservoir.h"
|
|
#include "lame-analysis.h"
|
|
#include <float.h>
|
|
|
|
|
|
#define NSATHSCALE 100 /* Assuming dynamic range=96dB, this value should be 92 */
|
|
|
|
/*
|
|
The following table is used to implement the scalefactor
|
|
partitioning for MPEG2 as described in section
|
|
2.4.3.2 of the IS. The indexing corresponds to the
|
|
way the tables are presented in the IS:
|
|
|
|
[table_number][row_in_table][column of nr_of_sfb]
|
|
*/
|
|
const int nr_of_sfb_block[6][3][4] = {
|
|
{
|
|
{6, 5, 5, 5},
|
|
{9, 9, 9, 9},
|
|
{6, 9, 9, 9}
|
|
},
|
|
{
|
|
{6, 5, 7, 3},
|
|
{9, 9, 12, 6},
|
|
{6, 9, 12, 6}
|
|
},
|
|
{
|
|
{11, 10, 0, 0},
|
|
{18, 18, 0, 0},
|
|
{15, 18, 0, 0}
|
|
},
|
|
{
|
|
{7, 7, 7, 0},
|
|
{12, 12, 12, 0},
|
|
{6, 15, 12, 0}
|
|
},
|
|
{
|
|
{6, 6, 6, 3},
|
|
{12, 9, 9, 6},
|
|
{6, 12, 9, 6}
|
|
},
|
|
{
|
|
{8, 8, 5, 0},
|
|
{15, 12, 9, 0},
|
|
{6, 18, 9, 0}
|
|
}
|
|
};
|
|
|
|
|
|
/* Table B.6: layer3 preemphasis */
|
|
const int pretab[SBMAX_l] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0
|
|
};
|
|
|
|
/*
|
|
Here are MPEG1 Table B.8 and MPEG2 Table B.1
|
|
-- Layer III scalefactor bands.
|
|
Index into this using a method such as:
|
|
idx = fr_ps->header->sampling_frequency
|
|
+ (fr_ps->header->version * 3)
|
|
*/
|
|
|
|
|
|
const scalefac_struct sfBandIndex[9] = {
|
|
{ /* Table B.2.b: 22.05 kHz */
|
|
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464,
|
|
522, 576},
|
|
{0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* Table B.2.c: 24 kHz */ /* docs: 332. mpg123(broken): 330 */
|
|
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464,
|
|
540, 576},
|
|
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* Table B.2.a: 16 kHz */
|
|
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464,
|
|
522, 576},
|
|
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* Table B.8.b: 44.1 kHz */
|
|
{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418,
|
|
576},
|
|
{0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* Table B.8.c: 48 kHz */
|
|
{0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384,
|
|
576},
|
|
{0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* Table B.8.a: 32 kHz */
|
|
{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550,
|
|
576},
|
|
{0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* MPEG-2.5 11.025 kHz */
|
|
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464,
|
|
522, 576},
|
|
{0 / 3, 12 / 3, 24 / 3, 36 / 3, 54 / 3, 78 / 3, 108 / 3, 144 / 3, 186 / 3, 240 / 3, 312 / 3,
|
|
402 / 3, 522 / 3, 576 / 3}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* MPEG-2.5 12 kHz */
|
|
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464,
|
|
522, 576},
|
|
{0 / 3, 12 / 3, 24 / 3, 36 / 3, 54 / 3, 78 / 3, 108 / 3, 144 / 3, 186 / 3, 240 / 3, 312 / 3,
|
|
402 / 3, 522 / 3, 576 / 3}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
},
|
|
{ /* MPEG-2.5 8 kHz */
|
|
{0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570,
|
|
572, 574, 576},
|
|
{0 / 3, 24 / 3, 48 / 3, 72 / 3, 108 / 3, 156 / 3, 216 / 3, 288 / 3, 372 / 3, 480 / 3, 486 / 3,
|
|
492 / 3, 498 / 3, 576 / 3}
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb21 pseudo sub bands */
|
|
, {0, 0, 0, 0, 0, 0, 0} /* sfb12 pseudo sub bands */
|
|
}
|
|
};
|
|
|
|
|
|
/* FIXME: move global variables in some struct */
|
|
|
|
FLOAT pow20[Q_MAX + Q_MAX2 + 1];
|
|
FLOAT ipow20[Q_MAX];
|
|
FLOAT pow43[PRECALC_SIZE];
|
|
/* initialized in first call to iteration_init */
|
|
#ifdef TAKEHIRO_IEEE754_HACK
|
|
FLOAT adj43asm[PRECALC_SIZE];
|
|
#else
|
|
FLOAT adj43[PRECALC_SIZE];
|
|
#endif
|
|
|
|
/*
|
|
compute the ATH for each scalefactor band
|
|
cd range: 0..96db
|
|
|
|
Input: 3.3kHz signal 32767 amplitude (3.3kHz is where ATH is smallest = -5db)
|
|
longblocks: sfb=12 en0/bw=-11db max_en0 = 1.3db
|
|
shortblocks: sfb=5 -9db 0db
|
|
|
|
Input: 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 (repeated)
|
|
longblocks: amp=1 sfb=12 en0/bw=-103 db max_en0 = -92db
|
|
amp=32767 sfb=12 -12 db -1.4db
|
|
|
|
Input: 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 (repeated)
|
|
shortblocks: amp=1 sfb=5 en0/bw= -99 -86
|
|
amp=32767 sfb=5 -9 db 4db
|
|
|
|
|
|
MAX energy of largest wave at 3.3kHz = 1db
|
|
AVE energy of largest wave at 3.3kHz = -11db
|
|
Let's take AVE: -11db = maximum signal in sfb=12.
|
|
Dynamic range of CD: 96db. Therefor energy of smallest audible wave
|
|
in sfb=12 = -11 - 96 = -107db = ATH at 3.3kHz.
|
|
|
|
ATH formula for this wave: -5db. To adjust to LAME scaling, we need
|
|
ATH = ATH_formula - 103 (db)
|
|
ATH = ATH * 2.5e-10 (ener)
|
|
|
|
*/
|
|
|
|
static FLOAT
|
|
ATHmdct(SessionConfig_t const *cfg, FLOAT f)
|
|
{
|
|
FLOAT ath;
|
|
|
|
ath = ATHformula(cfg, f);
|
|
|
|
if (cfg->ATHfixpoint > 0) {
|
|
ath -= cfg->ATHfixpoint;
|
|
}
|
|
else {
|
|
ath -= NSATHSCALE;
|
|
}
|
|
ath += cfg->ATH_offset_db;
|
|
|
|
/* modify the MDCT scaling for the ATH and convert to energy */
|
|
ath = powf(10.0f, ath * 0.1f);
|
|
return ath;
|
|
}
|
|
|
|
static void
|
|
compute_ath(lame_internal_flags const* gfc)
|
|
{
|
|
SessionConfig_t const *const cfg = &gfc->cfg;
|
|
FLOAT *const ATH_l = gfc->ATH->l;
|
|
FLOAT *const ATH_psfb21 = gfc->ATH->psfb21;
|
|
FLOAT *const ATH_s = gfc->ATH->s;
|
|
FLOAT *const ATH_psfb12 = gfc->ATH->psfb12;
|
|
int sfb, i, start, end;
|
|
FLOAT ATH_f;
|
|
FLOAT const samp_freq = cfg->samplerate_out;
|
|
|
|
for (sfb = 0; sfb < SBMAX_l; sfb++) {
|
|
start = gfc->scalefac_band.l[sfb];
|
|
end = gfc->scalefac_band.l[sfb + 1];
|
|
ATH_l[sfb] = FLOAT_MAX;
|
|
for (i = start; i < end; i++) {
|
|
FLOAT const freq = i * samp_freq / (2 * 576);
|
|
ATH_f = ATHmdct(cfg, freq); /* freq in kHz */
|
|
ATH_l[sfb] = Min(ATH_l[sfb], ATH_f);
|
|
}
|
|
}
|
|
|
|
for (sfb = 0; sfb < PSFB21; sfb++) {
|
|
start = gfc->scalefac_band.psfb21[sfb];
|
|
end = gfc->scalefac_band.psfb21[sfb + 1];
|
|
ATH_psfb21[sfb] = FLOAT_MAX;
|
|
for (i = start; i < end; i++) {
|
|
FLOAT const freq = i * samp_freq / (2 * 576);
|
|
ATH_f = ATHmdct(cfg, freq); /* freq in kHz */
|
|
ATH_psfb21[sfb] = Min(ATH_psfb21[sfb], ATH_f);
|
|
}
|
|
}
|
|
|
|
for (sfb = 0; sfb < SBMAX_s; sfb++) {
|
|
start = gfc->scalefac_band.s[sfb];
|
|
end = gfc->scalefac_band.s[sfb + 1];
|
|
ATH_s[sfb] = FLOAT_MAX;
|
|
for (i = start; i < end; i++) {
|
|
FLOAT const freq = i * samp_freq / (2 * 192);
|
|
ATH_f = ATHmdct(cfg, freq); /* freq in kHz */
|
|
ATH_s[sfb] = Min(ATH_s[sfb], ATH_f);
|
|
}
|
|
ATH_s[sfb] *= (gfc->scalefac_band.s[sfb + 1] - gfc->scalefac_band.s[sfb]);
|
|
}
|
|
|
|
for (sfb = 0; sfb < PSFB12; sfb++) {
|
|
start = gfc->scalefac_band.psfb12[sfb];
|
|
end = gfc->scalefac_band.psfb12[sfb + 1];
|
|
ATH_psfb12[sfb] = FLOAT_MAX;
|
|
for (i = start; i < end; i++) {
|
|
FLOAT const freq = i * samp_freq / (2 * 192);
|
|
ATH_f = ATHmdct(cfg, freq); /* freq in kHz */
|
|
ATH_psfb12[sfb] = Min(ATH_psfb12[sfb], ATH_f);
|
|
}
|
|
/*not sure about the following */
|
|
ATH_psfb12[sfb] *= (gfc->scalefac_band.s[13] - gfc->scalefac_band.s[12]);
|
|
}
|
|
|
|
|
|
/* no-ATH mode:
|
|
* reduce ATH to -200 dB
|
|
*/
|
|
|
|
if (cfg->noATH) {
|
|
for (sfb = 0; sfb < SBMAX_l; sfb++) {
|
|
ATH_l[sfb] = 1E-20;
|
|
}
|
|
for (sfb = 0; sfb < PSFB21; sfb++) {
|
|
ATH_psfb21[sfb] = 1E-20;
|
|
}
|
|
for (sfb = 0; sfb < SBMAX_s; sfb++) {
|
|
ATH_s[sfb] = 1E-20;
|
|
}
|
|
for (sfb = 0; sfb < PSFB12; sfb++) {
|
|
ATH_psfb12[sfb] = 1E-20;
|
|
}
|
|
}
|
|
|
|
/* work in progress, don't rely on it too much
|
|
*/
|
|
gfc->ATH->floor = 10. * log10(ATHmdct(cfg, -1.));
|
|
|
|
/*
|
|
{ FLOAT g=10000, t=1e30, x;
|
|
for ( f = 100; f < 10000; f++ ) {
|
|
x = ATHmdct( cfg, f );
|
|
if ( t > x ) t = x, g = f;
|
|
}
|
|
printf("min=%g\n", g);
|
|
} */
|
|
}
|
|
|
|
|
|
static float const payload_long[2][4] =
|
|
{ {-0.000f, -0.000f, -0.000f, +0.000f}
|
|
, {-0.500f, -0.250f, -0.025f, +0.500f}
|
|
};
|
|
static float const payload_short[2][4] =
|
|
{ {-0.000f, -0.000f, -0.000f, +0.000f}
|
|
, {-2.000f, -1.000f, -0.050f, +0.500f}
|
|
};
|
|
|
|
/************************************************************************/
|
|
/* initialization for iteration_loop */
|
|
/************************************************************************/
|
|
void
|
|
iteration_init(lame_internal_flags * gfc)
|
|
{
|
|
SessionConfig_t const *const cfg = &gfc->cfg;
|
|
III_side_info_t *const l3_side = &gfc->l3_side;
|
|
FLOAT adjust, db;
|
|
int i, sel;
|
|
|
|
if (gfc->iteration_init_init == 0) {
|
|
gfc->iteration_init_init = 1;
|
|
|
|
l3_side->main_data_begin = 0;
|
|
compute_ath(gfc);
|
|
|
|
pow43[0] = 0.0;
|
|
for (i = 1; i < PRECALC_SIZE; i++)
|
|
pow43[i] = pow((FLOAT) i, 4.0 / 3.0);
|
|
|
|
#ifdef TAKEHIRO_IEEE754_HACK
|
|
adj43asm[0] = 0.0;
|
|
for (i = 1; i < PRECALC_SIZE; i++)
|
|
adj43asm[i] = i - 0.5 - pow(0.5 * (pow43[i - 1] + pow43[i]), 0.75);
|
|
#else
|
|
for (i = 0; i < PRECALC_SIZE - 1; i++)
|
|
adj43[i] = (i + 1) - pow(0.5 * (pow43[i] + pow43[i + 1]), 0.75);
|
|
adj43[i] = 0.5;
|
|
#endif
|
|
for (i = 0; i < Q_MAX; i++)
|
|
ipow20[i] = pow(2.0, (double) (i - 210) * -0.1875);
|
|
for (i = 0; i <= Q_MAX + Q_MAX2; i++)
|
|
pow20[i] = pow(2.0, (double) (i - 210 - Q_MAX2) * 0.25);
|
|
|
|
huffman_init(gfc);
|
|
init_xrpow_core_init(gfc);
|
|
|
|
sel = 1;/* RH: all modes like vbr-new (cfg->vbr == vbr_mt || cfg->vbr == vbr_mtrh) ? 1 : 0;*/
|
|
|
|
/* long */
|
|
db = cfg->adjust_bass_db + payload_long[sel][0];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (i = 0; i <= 6; ++i) {
|
|
gfc->sv_qnt.longfact[i] = adjust;
|
|
}
|
|
db = cfg->adjust_alto_db + payload_long[sel][1];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (; i <= 13; ++i) {
|
|
gfc->sv_qnt.longfact[i] = adjust;
|
|
}
|
|
db = cfg->adjust_treble_db + payload_long[sel][2];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (; i <= 20; ++i) {
|
|
gfc->sv_qnt.longfact[i] = adjust;
|
|
}
|
|
db = cfg->adjust_sfb21_db + payload_long[sel][3];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (; i < SBMAX_l; ++i) {
|
|
gfc->sv_qnt.longfact[i] = adjust;
|
|
}
|
|
|
|
/* short */
|
|
db = cfg->adjust_bass_db + payload_short[sel][0];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (i = 0; i <= 2; ++i) {
|
|
gfc->sv_qnt.shortfact[i] = adjust;
|
|
}
|
|
db = cfg->adjust_alto_db + payload_short[sel][1];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (; i <= 6; ++i) {
|
|
gfc->sv_qnt.shortfact[i] = adjust;
|
|
}
|
|
db = cfg->adjust_treble_db + payload_short[sel][2];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (; i <= 11; ++i) {
|
|
gfc->sv_qnt.shortfact[i] = adjust;
|
|
}
|
|
db = cfg->adjust_sfb21_db + payload_short[sel][3];
|
|
adjust = powf(10.f, db * 0.1f);
|
|
for (; i < SBMAX_s; ++i) {
|
|
gfc->sv_qnt.shortfact[i] = adjust;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* 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;
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
reduce_side(int targ_bits[2], FLOAT ms_ener_ratio, int mean_bits, int max_bits)
|
|
{
|
|
int move_bits;
|
|
FLOAT fac;
|
|
|
|
assert(max_bits <= MAX_BITS_PER_GRANULE);
|
|
assert(targ_bits[0] + targ_bits[1] <= MAX_BITS_PER_GRANULE);
|
|
|
|
/* ms_ener_ratio = 0: allocate 66/33 mid/side fac=.33
|
|
* ms_ener_ratio =.5: allocate 50/50 mid/side fac= 0 */
|
|
/* 75/25 split is fac=.5 */
|
|
/* float fac = .50*(.5-ms_ener_ratio[gr])/.5; */
|
|
fac = .33 * (.5 - ms_ener_ratio) / .5;
|
|
if (fac < 0)
|
|
fac = 0;
|
|
if (fac > .5)
|
|
fac = .5;
|
|
|
|
/* number of bits to move from side channel to mid channel */
|
|
/* move_bits = fac*targ_bits[1]; */
|
|
move_bits = fac * .5 * (targ_bits[0] + targ_bits[1]);
|
|
|
|
if (move_bits > MAX_BITS_PER_CHANNEL - targ_bits[0]) {
|
|
move_bits = MAX_BITS_PER_CHANNEL - targ_bits[0];
|
|
}
|
|
if (move_bits < 0)
|
|
move_bits = 0;
|
|
|
|
if (targ_bits[1] >= 125) {
|
|
/* dont reduce side channel below 125 bits */
|
|
if (targ_bits[1] - move_bits > 125) {
|
|
|
|
/* if mid channel already has 2x more than average, dont bother */
|
|
/* mean_bits = bits per granule (for both channels) */
|
|
if (targ_bits[0] < mean_bits)
|
|
targ_bits[0] += move_bits;
|
|
targ_bits[1] -= move_bits;
|
|
}
|
|
else {
|
|
targ_bits[0] += targ_bits[1] - 125;
|
|
targ_bits[1] = 125;
|
|
}
|
|
}
|
|
|
|
move_bits = targ_bits[0] + targ_bits[1];
|
|
if (move_bits > max_bits) {
|
|
targ_bits[0] = (max_bits * targ_bits[0]) / move_bits;
|
|
targ_bits[1] = (max_bits * targ_bits[1]) / move_bits;
|
|
}
|
|
assert(targ_bits[0] <= MAX_BITS_PER_CHANNEL);
|
|
assert(targ_bits[1] <= MAX_BITS_PER_CHANNEL);
|
|
assert(targ_bits[0] + targ_bits[1] <= MAX_BITS_PER_GRANULE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Robert Hegemann 2001-04-27:
|
|
* this adjusts the ATH, keeping the original noise floor
|
|
* affects the higher frequencies more than the lower ones
|
|
*/
|
|
|
|
FLOAT
|
|
athAdjust(FLOAT a, FLOAT x, FLOAT athFloor, float ATHfixpoint)
|
|
{
|
|
/* work in progress
|
|
*/
|
|
FLOAT const o = 90.30873362f;
|
|
FLOAT const p = (ATHfixpoint < 1.f) ? 94.82444863f : ATHfixpoint;
|
|
FLOAT u = FAST_LOG10_X(x, 10.0f);
|
|
FLOAT const v = a * a;
|
|
FLOAT w = 0.0f;
|
|
u -= athFloor; /* undo scaling */
|
|
if (v > 1E-20f)
|
|
w = 1.f + FAST_LOG10_X(v, 10.0f / o);
|
|
if (w < 0)
|
|
w = 0.f;
|
|
u *= w;
|
|
u += athFloor + o - p; /* redo scaling */
|
|
|
|
return powf(10.f, 0.1f * u);
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
/* 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_internal_flags const *gfc,
|
|
III_psy_ratio const *const ratio, gr_info * const cod_info, FLOAT * pxmin)
|
|
{
|
|
SessionConfig_t const *const cfg = &gfc->cfg;
|
|
int sfb, gsfb, j = 0, ath_over = 0, k;
|
|
ATH_t const *const ATH = gfc->ATH;
|
|
const FLOAT *const xr = cod_info->xr;
|
|
int max_nonzero;
|
|
|
|
for (gsfb = 0; gsfb < cod_info->psy_lmax; gsfb++) {
|
|
FLOAT en0, xmin;
|
|
FLOAT rh1, rh2, rh3;
|
|
int width, l;
|
|
|
|
xmin = athAdjust(ATH->adjust_factor, ATH->l[gsfb], ATH->floor, cfg->ATHfixpoint);
|
|
xmin *= gfc->sv_qnt.longfact[gsfb];
|
|
|
|
width = cod_info->width[gsfb];
|
|
rh1 = xmin / width;
|
|
#ifdef DBL_EPSILON
|
|
rh2 = DBL_EPSILON;
|
|
#else
|
|
rh2 = 2.2204460492503131e-016;
|
|
#endif
|
|
en0 = 0.0;
|
|
for (l = 0; l < width; ++l) {
|
|
FLOAT const xa = xr[j++];
|
|
FLOAT const x2 = xa * xa;
|
|
en0 += x2;
|
|
rh2 += (x2 < rh1) ? x2 : rh1;
|
|
}
|
|
if (en0 > xmin)
|
|
ath_over++;
|
|
|
|
if (en0 < xmin) {
|
|
rh3 = en0;
|
|
}
|
|
else if (rh2 < xmin) {
|
|
rh3 = xmin;
|
|
}
|
|
else {
|
|
rh3 = rh2;
|
|
}
|
|
xmin = rh3;
|
|
{
|
|
FLOAT const e = ratio->en.l[gsfb];
|
|
if (e > 1e-12f) {
|
|
FLOAT x;
|
|
x = en0 * ratio->thm.l[gsfb] / e;
|
|
x *= gfc->sv_qnt.longfact[gsfb];
|
|
if (xmin < x)
|
|
xmin = x;
|
|
}
|
|
}
|
|
xmin = Max(xmin, DBL_EPSILON);
|
|
cod_info->energy_above_cutoff[gsfb] = (en0 > xmin+1e-14f) ? 1 : 0;
|
|
*pxmin++ = xmin;
|
|
} /* end of long block loop */
|
|
|
|
|
|
|
|
|
|
/*use this function to determine the highest non-zero coeff */
|
|
max_nonzero = 0;
|
|
for (k = 575; k > 0; --k) {
|
|
if (fabs(xr[k]) > 1e-12f) {
|
|
max_nonzero = k;
|
|
break;
|
|
}
|
|
}
|
|
if (cod_info->block_type != SHORT_TYPE) { /* NORM, START or STOP type, but not SHORT */
|
|
max_nonzero |= 1; /* only odd numbers */
|
|
}
|
|
else {
|
|
max_nonzero /= 6; /* 3 short blocks */
|
|
max_nonzero *= 6;
|
|
max_nonzero += 5;
|
|
}
|
|
|
|
if (gfc->sv_qnt.sfb21_extra == 0 && cfg->samplerate_out < 44000) {
|
|
int const sfb_l = (cfg->samplerate_out <= 8000) ? 17 : 21;
|
|
int const sfb_s = (cfg->samplerate_out <= 8000) ? 9 : 12;
|
|
int limit = 575;
|
|
if (cod_info->block_type != SHORT_TYPE) { /* NORM, START or STOP type, but not SHORT */
|
|
limit = gfc->scalefac_band.l[sfb_l]-1;
|
|
}
|
|
else {
|
|
limit = 3*gfc->scalefac_band.s[sfb_s]-1;
|
|
}
|
|
if (max_nonzero > limit) {
|
|
max_nonzero = limit;
|
|
}
|
|
}
|
|
cod_info->max_nonzero_coeff = max_nonzero;
|
|
|
|
|
|
|
|
for (sfb = cod_info->sfb_smin; gsfb < cod_info->psymax; sfb++, gsfb += 3) {
|
|
int width, b, l;
|
|
FLOAT tmpATH;
|
|
|
|
tmpATH = athAdjust(ATH->adjust_factor, ATH->s[sfb], ATH->floor, cfg->ATHfixpoint);
|
|
tmpATH *= gfc->sv_qnt.shortfact[sfb];
|
|
|
|
width = cod_info->width[gsfb];
|
|
for (b = 0; b < 3; b++) {
|
|
FLOAT en0 = 0.0, xmin = tmpATH;
|
|
FLOAT rh1, rh2, rh3;
|
|
|
|
rh1 = tmpATH / width;
|
|
#ifdef DBL_EPSILON
|
|
rh2 = DBL_EPSILON;
|
|
#else
|
|
rh2 = 2.2204460492503131e-016;
|
|
#endif
|
|
for (l = 0; l < width; ++l) {
|
|
FLOAT const xa = xr[j++];
|
|
FLOAT const x2 = xa * xa;
|
|
en0 += x2;
|
|
rh2 += (x2 < rh1) ? x2 : rh1;
|
|
}
|
|
if (en0 > tmpATH)
|
|
ath_over++;
|
|
|
|
if (en0 < tmpATH) {
|
|
rh3 = en0;
|
|
}
|
|
else if (rh2 < tmpATH) {
|
|
rh3 = tmpATH;
|
|
}
|
|
else {
|
|
rh3 = rh2;
|
|
}
|
|
xmin = rh3;
|
|
{
|
|
FLOAT const e = ratio->en.s[sfb][b];
|
|
if (e > 1e-12f) {
|
|
FLOAT x;
|
|
x = en0 * ratio->thm.s[sfb][b] / e;
|
|
x *= gfc->sv_qnt.shortfact[sfb];
|
|
if (xmin < x)
|
|
xmin = x;
|
|
}
|
|
}
|
|
xmin = Max(xmin, DBL_EPSILON);
|
|
cod_info->energy_above_cutoff[gsfb+b] = (en0 > xmin+1e-14f) ? 1 : 0;
|
|
*pxmin++ = xmin;
|
|
} /* b */
|
|
if (cfg->use_temporal_masking_effect) {
|
|
if (pxmin[-3] > pxmin[-3 + 1])
|
|
pxmin[-3 + 1] += (pxmin[-3] - pxmin[-3 + 1]) * gfc->cd_psy->decay;
|
|
if (pxmin[-3 + 1] > pxmin[-3 + 2])
|
|
pxmin[-3 + 2] += (pxmin[-3 + 1] - pxmin[-3 + 2]) * gfc->cd_psy->decay;
|
|
}
|
|
} /* end of short block sfb loop */
|
|
|
|
return ath_over;
|
|
}
|
|
|
|
|
|
static FLOAT
|
|
calc_noise_core_c(const gr_info * const cod_info, int *startline, int l, FLOAT step)
|
|
{
|
|
FLOAT noise = 0;
|
|
int j = *startline;
|
|
const int *const ix = cod_info->l3_enc;
|
|
|
|
if (j > cod_info->count1) {
|
|
while (l--) {
|
|
FLOAT temp;
|
|
temp = cod_info->xr[j];
|
|
j++;
|
|
noise += temp * temp;
|
|
temp = cod_info->xr[j];
|
|
j++;
|
|
noise += temp * temp;
|
|
}
|
|
}
|
|
else if (j > cod_info->big_values) {
|
|
FLOAT ix01[2];
|
|
ix01[0] = 0;
|
|
ix01[1] = step;
|
|
while (l--) {
|
|
FLOAT temp;
|
|
temp = fabs(cod_info->xr[j]) - ix01[ix[j]];
|
|
j++;
|
|
noise += temp * temp;
|
|
temp = fabs(cod_info->xr[j]) - ix01[ix[j]];
|
|
j++;
|
|
noise += temp * temp;
|
|
}
|
|
}
|
|
else {
|
|
while (l--) {
|
|
FLOAT temp;
|
|
temp = fabs(cod_info->xr[j]) - pow43[ix[j]] * step;
|
|
j++;
|
|
noise += temp * temp;
|
|
temp = fabs(cod_info->xr[j]) - pow43[ix[j]] * step;
|
|
j++;
|
|
noise += temp * temp;
|
|
}
|
|
}
|
|
|
|
*startline = j;
|
|
return noise;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* calc_noise */
|
|
/*************************************************************************/
|
|
|
|
/* -oo dB => -1.00 */
|
|
/* - 6 dB => -0.97 */
|
|
/* - 3 dB => -0.80 */
|
|
/* - 2 dB => -0.64 */
|
|
/* - 1 dB => -0.38 */
|
|
/* 0 dB => 0.00 */
|
|
/* + 1 dB => +0.49 */
|
|
/* + 2 dB => +1.06 */
|
|
/* + 3 dB => +1.68 */
|
|
/* + 6 dB => +3.69 */
|
|
/* +10 dB => +6.45 */
|
|
|
|
int
|
|
calc_noise(gr_info const *const cod_info,
|
|
FLOAT const *l3_xmin,
|
|
FLOAT * distort, calc_noise_result * const res, calc_noise_data * prev_noise)
|
|
{
|
|
int sfb, l, over = 0;
|
|
FLOAT over_noise_db = 0;
|
|
FLOAT tot_noise_db = 0; /* 0 dB relative to masking */
|
|
FLOAT max_noise = -20.0; /* -200 dB relative to masking */
|
|
int j = 0;
|
|
const int *scalefac = cod_info->scalefac;
|
|
|
|
res->over_SSD = 0;
|
|
|
|
|
|
for (sfb = 0; sfb < cod_info->psymax; sfb++) {
|
|
int const s =
|
|
cod_info->global_gain - (((*scalefac++) + (cod_info->preflag ? pretab[sfb] : 0))
|
|
<< (cod_info->scalefac_scale + 1))
|
|
- cod_info->subblock_gain[cod_info->window[sfb]] * 8;
|
|
FLOAT const r_l3_xmin = 1.f / *l3_xmin++;
|
|
FLOAT distort_ = 0.0f;
|
|
FLOAT noise = 0.0f;
|
|
|
|
if (prev_noise && (prev_noise->step[sfb] == s)) {
|
|
|
|
/* use previously computed values */
|
|
j += cod_info->width[sfb];
|
|
distort_ = r_l3_xmin * prev_noise->noise[sfb];
|
|
|
|
noise = prev_noise->noise_log[sfb];
|
|
|
|
}
|
|
else {
|
|
FLOAT const step = POW20(s);
|
|
l = cod_info->width[sfb] >> 1;
|
|
|
|
if ((j + cod_info->width[sfb]) > cod_info->max_nonzero_coeff) {
|
|
int usefullsize;
|
|
usefullsize = cod_info->max_nonzero_coeff - j + 1;
|
|
|
|
if (usefullsize > 0)
|
|
l = usefullsize >> 1;
|
|
else
|
|
l = 0;
|
|
}
|
|
|
|
noise = calc_noise_core_c(cod_info, &j, l, step);
|
|
|
|
|
|
if (prev_noise) {
|
|
/* save noise values */
|
|
prev_noise->step[sfb] = s;
|
|
prev_noise->noise[sfb] = noise;
|
|
}
|
|
|
|
distort_ = r_l3_xmin * noise;
|
|
|
|
/* multiplying here is adding in dB, but can overflow */
|
|
noise = FAST_LOG10(Max(distort_, 1E-20f));
|
|
|
|
if (prev_noise) {
|
|
/* save noise values */
|
|
prev_noise->noise_log[sfb] = noise;
|
|
}
|
|
}
|
|
*distort++ = distort_;
|
|
|
|
if (prev_noise) {
|
|
/* save noise values */
|
|
prev_noise->global_gain = cod_info->global_gain;;
|
|
}
|
|
|
|
|
|
/*tot_noise *= Max(noise, 1E-20); */
|
|
tot_noise_db += noise;
|
|
|
|
if (noise > 0.0) {
|
|
int tmp;
|
|
|
|
tmp = Max((int) (noise * 10 + .5), 1);
|
|
res->over_SSD += tmp * tmp;
|
|
|
|
over++;
|
|
/* multiplying here is adding in dB -but can overflow */
|
|
/*over_noise *= noise; */
|
|
over_noise_db += noise;
|
|
}
|
|
max_noise = Max(max_noise, noise);
|
|
|
|
}
|
|
|
|
res->over_count = over;
|
|
res->tot_noise = tot_noise_db;
|
|
res->over_noise = over_noise_db;
|
|
res->max_noise = max_noise;
|
|
|
|
return over;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
*
|
|
* set_pinfo()
|
|
*
|
|
* updates plotting data
|
|
*
|
|
* Mark Taylor 2000-??-??
|
|
*
|
|
* Robert Hegemann: moved noise/distortion calc into it
|
|
*
|
|
************************************************************************/
|
|
|
|
static void
|
|
set_pinfo(lame_internal_flags const *gfc,
|
|
gr_info * const cod_info, const III_psy_ratio * const ratio, const int gr, const int ch)
|
|
{
|
|
SessionConfig_t const *const cfg = &gfc->cfg;
|
|
int sfb, sfb2;
|
|
int j, i, l, start, end, bw;
|
|
FLOAT en0, en1;
|
|
FLOAT const ifqstep = (cod_info->scalefac_scale == 0) ? .5 : 1.0;
|
|
int const *const scalefac = cod_info->scalefac;
|
|
|
|
FLOAT l3_xmin[SFBMAX], xfsf[SFBMAX];
|
|
calc_noise_result noise;
|
|
|
|
(void) calc_xmin(gfc, ratio, cod_info, l3_xmin);
|
|
(void) calc_noise(cod_info, l3_xmin, xfsf, &noise, 0);
|
|
|
|
j = 0;
|
|
sfb2 = cod_info->sfb_lmax;
|
|
if (cod_info->block_type != SHORT_TYPE && !cod_info->mixed_block_flag)
|
|
sfb2 = 22;
|
|
for (sfb = 0; sfb < sfb2; sfb++) {
|
|
start = gfc->scalefac_band.l[sfb];
|
|
end = gfc->scalefac_band.l[sfb + 1];
|
|
bw = end - start;
|
|
for (en0 = 0.0; j < end; j++)
|
|
en0 += cod_info->xr[j] * cod_info->xr[j];
|
|
en0 /= bw;
|
|
/* convert to MDCT units */
|
|
en1 = 1e15; /* scaling so it shows up on FFT plot */
|
|
gfc->pinfo->en[gr][ch][sfb] = en1 * en0;
|
|
gfc->pinfo->xfsf[gr][ch][sfb] = en1 * l3_xmin[sfb] * xfsf[sfb] / bw;
|
|
|
|
if (ratio->en.l[sfb] > 0 && !cfg->ATHonly)
|
|
en0 = en0 / ratio->en.l[sfb];
|
|
else
|
|
en0 = 0.0;
|
|
|
|
gfc->pinfo->thr[gr][ch][sfb] = en1 * Max(en0 * ratio->thm.l[sfb], gfc->ATH->l[sfb]);
|
|
|
|
/* there is no scalefactor bands >= SBPSY_l */
|
|
gfc->pinfo->LAMEsfb[gr][ch][sfb] = 0;
|
|
if (cod_info->preflag && sfb >= 11)
|
|
gfc->pinfo->LAMEsfb[gr][ch][sfb] = -ifqstep * pretab[sfb];
|
|
|
|
if (sfb < SBPSY_l) {
|
|
assert(scalefac[sfb] >= 0); /* scfsi should be decoded by caller side */
|
|
gfc->pinfo->LAMEsfb[gr][ch][sfb] -= ifqstep * scalefac[sfb];
|
|
}
|
|
} /* for sfb */
|
|
|
|
if (cod_info->block_type == SHORT_TYPE) {
|
|
sfb2 = sfb;
|
|
for (sfb = cod_info->sfb_smin; sfb < SBMAX_s; sfb++) {
|
|
start = gfc->scalefac_band.s[sfb];
|
|
end = gfc->scalefac_band.s[sfb + 1];
|
|
bw = end - start;
|
|
for (i = 0; i < 3; i++) {
|
|
for (en0 = 0.0, l = start; l < end; l++) {
|
|
en0 += cod_info->xr[j] * cod_info->xr[j];
|
|
j++;
|
|
}
|
|
en0 = Max(en0 / bw, 1e-20);
|
|
/* convert to MDCT units */
|
|
en1 = 1e15; /* scaling so it shows up on FFT plot */
|
|
|
|
gfc->pinfo->en_s[gr][ch][3 * sfb + i] = en1 * en0;
|
|
gfc->pinfo->xfsf_s[gr][ch][3 * sfb + i] = en1 * l3_xmin[sfb2] * xfsf[sfb2] / bw;
|
|
if (ratio->en.s[sfb][i] > 0)
|
|
en0 = en0 / ratio->en.s[sfb][i];
|
|
else
|
|
en0 = 0.0;
|
|
if (cfg->ATHonly || cfg->ATHshort)
|
|
en0 = 0;
|
|
|
|
gfc->pinfo->thr_s[gr][ch][3 * sfb + i] =
|
|
en1 * Max(en0 * ratio->thm.s[sfb][i], gfc->ATH->s[sfb]);
|
|
|
|
/* there is no scalefactor bands >= SBPSY_s */
|
|
gfc->pinfo->LAMEsfb_s[gr][ch][3 * sfb + i]
|
|
= -2.0 * cod_info->subblock_gain[i];
|
|
if (sfb < SBPSY_s) {
|
|
gfc->pinfo->LAMEsfb_s[gr][ch][3 * sfb + i] -= ifqstep * scalefac[sfb2];
|
|
}
|
|
sfb2++;
|
|
}
|
|
}
|
|
} /* block type short */
|
|
gfc->pinfo->LAMEqss[gr][ch] = cod_info->global_gain;
|
|
gfc->pinfo->LAMEmainbits[gr][ch] = cod_info->part2_3_length + cod_info->part2_length;
|
|
gfc->pinfo->LAMEsfbits[gr][ch] = cod_info->part2_length;
|
|
|
|
gfc->pinfo->over[gr][ch] = noise.over_count;
|
|
gfc->pinfo->max_noise[gr][ch] = noise.max_noise * 10.0;
|
|
gfc->pinfo->over_noise[gr][ch] = noise.over_noise * 10.0;
|
|
gfc->pinfo->tot_noise[gr][ch] = noise.tot_noise * 10.0;
|
|
gfc->pinfo->over_SSD[gr][ch] = noise.over_SSD;
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
*
|
|
* set_frame_pinfo()
|
|
*
|
|
* updates plotting data for a whole frame
|
|
*
|
|
* Robert Hegemann 2000-10-21
|
|
*
|
|
************************************************************************/
|
|
|
|
void
|
|
set_frame_pinfo(lame_internal_flags * gfc, const III_psy_ratio ratio[2][2])
|
|
{
|
|
SessionConfig_t const *const cfg = &gfc->cfg;
|
|
int ch;
|
|
int gr;
|
|
|
|
/* for every granule and channel patch l3_enc and set info
|
|
*/
|
|
for (gr = 0; gr < cfg->mode_gr; gr++) {
|
|
for (ch = 0; ch < cfg->channels_out; ch++) {
|
|
gr_info *const cod_info = &gfc->l3_side.tt[gr][ch];
|
|
int scalefac_sav[SFBMAX];
|
|
memcpy(scalefac_sav, cod_info->scalefac, sizeof(scalefac_sav));
|
|
|
|
/* reconstruct the scalefactors in case SCFSI was used
|
|
*/
|
|
if (gr == 1) {
|
|
int sfb;
|
|
for (sfb = 0; sfb < cod_info->sfb_lmax; sfb++) {
|
|
if (cod_info->scalefac[sfb] < 0) /* scfsi */
|
|
cod_info->scalefac[sfb] = gfc->l3_side.tt[0][ch].scalefac[sfb];
|
|
}
|
|
}
|
|
|
|
set_pinfo(gfc, cod_info, &ratio[gr][ch], gr, ch);
|
|
memcpy(cod_info->scalefac, scalefac_sav, sizeof(scalefac_sav));
|
|
} /* for ch */
|
|
} /* for gr */
|
|
}
|