Go to the documentation of this file.
41 for (n = 0; n < 320; n++)
48 const void *sbr_codes, *sbr_bits;
49 const unsigned int table_size, elem_size;
94 if(sbr->mdct.mdct_bits)
96 sbr->kx[0] = sbr->kx[1];
119 return *(
const int16_t *)
a - *(
const int16_t *)
b;
125 for (
i = 0;
i <= last_el;
i++)
136 static const INTFLOAT bands_warped[3] = {
Q23(1.32715174233856803909
f),
137 Q23(1.18509277094158210129
f),
138 Q23(1.11987160404675912501
f) };
140 int16_t patch_borders[7];
143 patch_borders[0] = sbr->
kx[1];
150 memcpy(sbr->
f_tablelim + sbr->
n[0] + 1, patch_borders + 1,
151 (sbr->
num_patches - 1) *
sizeof(patch_borders[0]));
158 while (out < sbr->f_tablelim + sbr->
n_lim) {
160 if ((*in << 23) >= *
out * lim_bands_per_octave_warped) {
162 if (*in >= *
out * lim_bands_per_octave_warped) {
165 }
else if (*in == *
out ||
186 uint8_t bs_header_extra_1;
187 uint8_t bs_header_extra_2;
206 if (bs_header_extra_1) {
220 if (bs_header_extra_2) {
241 for (
i = 1;
i < nel;
i++)
253 if (bs_xover_band >= n_master) {
255 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
266 unsigned int temp, max_qmf_subbands = 0;
267 unsigned int start_min, stop_min;
269 const int8_t *sbr_offset_ptr;
285 case 44100:
case 48000:
case 64000:
288 case 88200:
case 96000:
case 128000:
case 176400:
case 192000:
293 "Unsupported sample rate for SBR: %d\n", sbr->
sample_rate);
310 sbr->
k[2] = stop_min;
314 sbr->
k[2] += stop_dk[k];
316 sbr->
k[2] = 2*sbr->
k[0];
318 sbr->
k[2] = 3*sbr->
k[0];
324 sbr->
k[2] =
FFMIN(64, sbr->
k[2]);
328 max_qmf_subbands = 48;
330 max_qmf_subbands = 35;
332 max_qmf_subbands = 32;
336 if (sbr->
k[2] - sbr->
k[0] > max_qmf_subbands) {
338 "Invalid bitstream, too many QMF subbands: %d\n", sbr->
k[2] - sbr->
k[0]);
346 sbr->
n_master = ((sbr->
k[2] - sbr->
k[0] + (dk&2)) >> dk) << 1;
350 for (k = 1; k <= sbr->
n_master; k++)
353 k2diff = sbr->
k[2] - sbr->
k[0] - sbr->
n_master * dk;
362 for (k = 1; k <= sbr->
n_master; k++)
367 int two_regions, num_bands_0;
368 int vdk0_max, vdk1_min;
374 if (49 * sbr->
k[2] > 110 * sbr->
k[0]) {
376 sbr->
k[1] = 2 * sbr->
k[0];
379 sbr->
k[1] = sbr->
k[2];
383 tmp = (sbr->
k[1] << 23) / sbr->
k[0];
384 while (
tmp < 0x40000000) {
390 tmp = (((
tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
391 num_bands_0 = ((
tmp + 0x400000) >> 23) * 2;
393 num_bands_0 =
lrintf(half_bands *
log2f(sbr->
k[1] / (
float)sbr->
k[0])) * 2;
396 if (num_bands_0 <= 0) {
406 vdk0_max = vk0[num_bands_0];
409 for (k = 1; k <= num_bands_0; k++) {
422 tmp = (sbr->
k[2] << 23) / sbr->
k[1];
424 while (
tmp < 0x40000000) {
430 tmp = (((
tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
433 num_bands_1 = ((
tmp + 0x400000) >> 23) * 2;
435 float invwarp = spectrum->
bs_alter_scale ? 0.76923076923076923077f
437 int num_bands_1 =
lrintf(half_bands * invwarp *
438 log2f(sbr->
k[2] / (
float)sbr->
k[1])) * 2;
444 if (vdk1_min < vdk0_max) {
447 change =
FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
449 vk1[num_bands_1] -= change;
455 for (k = 1; k <= num_bands_1; k++) {
463 sbr->
n_master = num_bands_0 + num_bands_1;
467 (num_bands_0 + 1) *
sizeof(sbr->
f_master[0]));
468 memcpy(&sbr->
f_master[num_bands_0 + 1], vk1 + 1,
469 num_bands_1 *
sizeof(sbr->
f_master[0]));
485 int i, k, last_k = -1, last_msb = -1, sb = 0;
487 int usb = sbr->
kx[1];
492 if (goal_sb < sbr->kx[1] + sbr->
m[1]) {
493 for (k = 0; sbr->
f_master[k] < goal_sb; k++) ;
499 if (k == last_k && msb == last_msb) {
505 for (
i = k;
i == k || sb > (sbr->
k[0] - 1 + msb - odd);
i--) {
507 odd = (sb + sbr->
k[0]) & 1;
531 }
while (sb != sbr->
kx[1] + sbr->
m[1]);
549 sbr->
n[0] = (sbr->
n[1] + 1) >> 1;
552 (sbr->
n[1] + 1) *
sizeof(sbr->
f_master[0]));
557 if (sbr->
kx[1] + sbr->
m[1] > 64) {
559 "Stop frequency border too high: %d\n", sbr->
kx[1] + sbr->
m[1]);
562 if (sbr->
kx[1] > 32) {
568 temp = sbr->
n[1] & 1;
569 for (k = 1; k <= sbr->
n[0]; k++)
572 temp = (sbr->
k[2] << 23) / sbr->
kx[1];
573 while (
temp < 0x40000000) {
581 sbr->
n_q = (
temp + 0x400000) >> 23;
586 log2f(sbr->
k[2] / (
float)sbr->
kx[1])));
596 for (k = 1; k <= sbr->
n_q; k++) {
632 int abs_bord_trail = 16;
633 int num_rel_lead, num_rel_trail;
634 unsigned bs_num_env_old = ch_data->
bs_num_env;
635 int bs_frame_class, bs_num_env;
641 switch (bs_frame_class =
get_bits(gb, 2)) {
644 if (bs_num_env > 4) {
646 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
656 ch_data->
t_env[0] = 0;
659 abs_bord_trail = (abs_bord_trail + (ch_data->
bs_num_env >> 1)) /
661 for (
i = 0;
i < num_rel_lead;
i++)
662 ch_data->
t_env[
i + 1] = ch_data->
t_env[
i] + abs_bord_trail;
672 ch_data->
t_env[0] = 0;
675 for (
i = 0;
i < num_rel_trail;
i++)
690 for (
i = 0;
i < num_rel_lead;
i++)
702 bs_num_env = num_rel_lead + num_rel_trail + 1;
704 if (bs_num_env > 5) {
706 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
714 for (
i = 0;
i < num_rel_lead;
i++)
716 for (
i = 0;
i < num_rel_trail;
i++)
730 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
744 ch_data->
t_q[0] = ch_data->
t_env[0];
755 else if (bs_pointer == 1)
758 idx = bs_pointer - 1;
760 ch_data->
t_q[1] = ch_data->
t_env[idx];
763 ch_data->
e_a[0] = -(ch_data->
e_a[1] != bs_num_env_old);
764 ch_data->
e_a[1] = -1;
768 ch_data->
e_a[1] = bs_pointer - 1;
782 memcpy(dst->
t_q,
src->t_q,
sizeof(dst->
t_q));
787 dst->
e_a[1] =
src->e_a[1];
805 for (
i = 0;
i < sbr->
n_q;
i++)
814 const VLCElem *t_huff, *f_huff;
817 const int odd = sbr->
n[1] & 1;
871 k = j ? 2*j - odd : 0;
902 const VLCElem *t_huff, *f_huff;
920 for (j = 0; j < sbr->
n_q; j++) {
929 for (j = 1; j < sbr->
n_q; j++) {
947 int bs_extension_id,
int *num_bits_left)
949 switch (bs_extension_id) {
952 av_log(ac->
avctx,
AV_LOG_ERROR,
"Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
964 if (bs_extension_id || *num_bits_left > 16 ||
show_bits(gb, *num_bits_left))
1068 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1073 int num_bits_left =
get_bits(gb, 4);
1074 if (num_bits_left == 15)
1077 num_bits_left <<= 3;
1078 while (num_bits_left > 7) {
1082 if (num_bits_left < 0) {
1085 if (num_bits_left > 0)
1100 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1116 unsigned int num_sbr_bits = 0, num_align_bits;
1117 unsigned bytes_read;
1123 if (!sbr->sample_rate)
1124 sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1125 if (!ac->oc[1].m4ac.ext_sample_rate)
1126 ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1134 sbr->kx[0] = sbr->kx[1];
1135 sbr->m[0] = sbr->m[1];
1136 sbr->kx_and_m_pushed = 1;
1148 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1149 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1151 if (bytes_read > cnt) {
1153 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1165 #ifndef sbr_qmf_analysis
1178 memcpy(x , x+1024, (320-32)*
sizeof(x[0]));
1179 memcpy(x+288, in, 1024*
sizeof(x[0]));
1180 for (
i = 0;
i < 32;
i++) {
1184 sbrdsp->qmf_pre_shuffle(z);
1186 for (j = 64; j < 128; j++) {
1189 "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1192 }
else if (z[j] < -(1<<24)) {
1194 "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1201 sbrdsp->qmf_post_shuffle(
W[buf_idx][
i], z);
1211 #ifndef sbr_qmf_synthesis
1220 INTFLOAT *
v0,
int *v_off,
const unsigned int div)
1224 const int step = 128 >> div;
1226 for (
i = 0;
i < 32;
i++) {
1227 if (*v_off <
step) {
1228 int saved_samples = (1280 - 128) >> div;
1236 for (n = 0; n < 32; n++) {
1237 X[0][
i][ n] = -
X[0][
i][n];
1238 X[0][
i][32+n] =
X[1][
i][31-n];
1241 sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1243 sbrdsp->neg_odd_64(
X[1][
i]);
1246 sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1269 const int t_HFGen = 8;
1271 memset(X_low, 0, 32*
sizeof(*X_low));
1272 for (k = 0; k < sbr->
kx[1]; k++) {
1273 for (
i = t_HFGen;
i < i_f + t_HFGen;
i++) {
1274 X_low[k][
i][0] =
W[buf_idx][
i - t_HFGen][k][0];
1275 X_low[k][
i][1] =
W[buf_idx][
i - t_HFGen][k][1];
1278 buf_idx = 1-buf_idx;
1279 for (k = 0; k < sbr->
kx[0]; k++) {
1280 for (
i = 0;
i < t_HFGen;
i++) {
1281 X_low[k][
i][0] =
W[buf_idx][
i + i_f - t_HFGen][k][0];
1282 X_low[k][
i][1] =
W[buf_idx][
i + i_f - t_HFGen][k][1];
1292 const INTFLOAT bw_array[5],
const uint8_t *t_env,
1307 "ERROR : no subband found for frequency %d\n", k);
1313 alpha0[p], alpha1[p], bw_array[
g],
1314 2 * t_env[0], 2 * t_env[bs_num_env]);
1317 if (k < sbr->m[1] + sbr->
kx[1])
1318 memset(X_high + k, 0, (sbr->
m[1] + sbr->
kx[1] - k) *
sizeof(*X_high));
1326 const INTFLOAT X_low[32][40][2],
int ch)
1331 memset(
X, 0, 2*
sizeof(*
X));
1332 for (k = 0; k < sbr->
kx[0]; k++) {
1333 for (
i = 0;
i < i_Temp;
i++) {
1338 for (; k < sbr->
kx[0] + sbr->
m[0]; k++) {
1339 for (
i = 0;
i < i_Temp;
i++) {
1340 X[0][
i][k] = Y0[
i + i_f][k][0];
1341 X[1][
i][k] = Y0[
i + i_f][k][1];
1345 for (k = 0; k < sbr->
kx[1]; k++) {
1346 for (
i = i_Temp;
i < 38;
i++) {
1351 for (; k < sbr->
kx[1] + sbr->
m[1]; k++) {
1352 for (
i = i_Temp;
i < i_f;
i++) {
1353 X[0][
i][k] = Y1[
i][k][0];
1354 X[1][
i][k] = Y1[
i][k][1];
1370 const unsigned int ilim = sbr->
n[ch_data->
bs_freq_res[e + 1]];
1376 "Derived frequency tables were not regenerated.\n");
1380 for (
i = 0;
i < ilim;
i++)
1386 for (
i = 0;
i < sbr->
n_q;
i++)
1387 for (m = sbr->
f_tablenoise[
i]; m < sbr->f_tablenoise[
i + 1]; m++)
1390 for (
i = 0;
i < sbr->
n[1];
i++) {
1392 const unsigned int m_midpoint =
1396 (e >= e_a[1] || (ch_data->
s_indexmapped[0][m_midpoint - sbr->
kx[1]] == 1));
1400 for (
i = 0;
i < ilim;
i++) {
1401 int additional_sinusoid_present = 0;
1404 additional_sinusoid_present = 1;
1408 memset(&sbr->
s_mapped[e][
table[
i] - sbr->
kx[1]], additional_sinusoid_present,
1422 int kx1 = sbr->
kx[1];
1429 const float recip_env_size = 0.5f / (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1434 for (m = 0; m < sbr->
m[1]; m++) {
1437 e_curr[e][m] =
av_mul_sf(sum, recip_env_size);
1439 e_curr[e][m] = sum * recip_env_size;
1447 const int env_size = 2 * (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1452 for (p = 0; p < sbr->
n[ch_data->
bs_freq_res[e + 1]]; p++) {
1462 const int den = env_size * (
table[p + 1] -
table[p]);
1470 e_curr[e][k - kx1] = sum;
1480 int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1482 int nch = (id_aac ==
TYPE_CPE) ? 2 : 1;
1485 if (id_aac != sbr->id_aac) {
1487 "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
1491 if (sbr->start && !sbr->ready_for_dequant) {
1493 "No quantized data read for sbr_dequant.\n");
1497 if (!sbr->kx_and_m_pushed) {
1498 sbr->kx[0] = sbr->kx[1];
1499 sbr->m[0] = sbr->m[1];
1501 sbr->kx_and_m_pushed = 0;
1506 sbr->ready_for_dequant = 0;
1508 for (ch = 0; ch < nch; ch++) {
1510 sbr_qmf_analysis(ac->fdsp, &sbr->mdct_ana, &sbr->dsp, ch ?
R :
L, sbr->data[ch].analysis_filterbank_samples,
1511 (
INTFLOAT*)sbr->qmf_filter_scratch,
1512 sbr->data[ch].W, sbr->data[ch].Ypos);
1513 sbr->c.sbr_lf_gen(ac, sbr, sbr->X_low,
1514 (
const INTFLOAT (*)[32][32][2]) sbr->data[ch].W,
1515 sbr->data[ch].Ypos);
1516 sbr->data[ch].Ypos ^= 1;
1518 sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
1519 (
const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]);
1523 (
const INTFLOAT (*)[40][2]) sbr->X_low,
1524 (
const INTFLOAT (*)[2]) sbr->alpha0,
1525 (
const INTFLOAT (*)[2]) sbr->alpha1,
1526 sbr->data[ch].bw_array, sbr->data[ch].t_env,
1527 sbr->data[ch].bs_num_env);
1530 err =
sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1534 sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
1535 (
const INTFLOAT (*)[40][2]) sbr->X_high,
1536 sbr, &sbr->data[ch],
1542 sbr->c.sbr_x_gen(sbr, sbr->X[ch],
1543 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos],
1544 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[ sbr->data[ch].Ypos],
1545 (
const INTFLOAT (*)[40][2]) sbr->X_low, ch);
1548 if (ac->oc[1].m4ac.ps == 1) {
1549 if (sbr->ps.common.start) {
1552 memcpy(sbr->X[1], sbr->X[0],
sizeof(sbr->X[0]));
1558 L, sbr->X[0], sbr->qmf_filter_scratch,
1559 sbr->data[0].synthesis_filterbank_samples,
1560 &sbr->data[0].synthesis_filterbank_samples_offset,
1564 R, sbr->X[1], sbr->qmf_filter_scratch,
1565 sbr->data[1].synthesis_filterbank_samples,
1566 &sbr->data[1].synthesis_filterbank_samples_offset,
void(* hf_gen)(INTFLOAT(*X_high)[2], const INTFLOAT(*X_low)[2], const INTFLOAT alpha0[2], const INTFLOAT alpha1[2], INTFLOAT bw, int start, int end)
static void sbr_qmf_synthesis(FFTContext *mdct, SBRDSPContext *sbrdsp, AVFloatDSPContext *dsp, INTFLOAT *out, INTFLOAT X[2][38][64], INTFLOAT mdct_buf[2][64], INTFLOAT *v0, int *v_off, const unsigned int div)
Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank (14496-3 sp04 p206)
static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
av_cold void AAC_RENAME() ff_aac_sbr_init(void)
Initialize SBR.
unsigned bs_limiter_gains
static const ElemCat * elements[ELEMENT_COUNT]
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
AAC_FLOAT env_facs[6][48]
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
av_cold void AAC_RENAME() ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
Close one SBR context.
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
static int get_bits_count(const GetBitContext *s)
static void sbr_hf_inverse_filter(SBRDSPContext *dsp, float(*alpha0)[2], float(*alpha1)[2], const float X_low[32][40][2], int k0)
High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering (14496-3 sp04 p214) Warning: Thi...
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
static const uint16_t table[]
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
static void copy_sbr_grid(SBRData *dst, const SBRData *src)
#define AV_LOG_VERBOSE
Detailed information.
av_cold void AAC_RENAME() ff_ps_init(void)
uint8_t t_env[8]
Envelope time borders.
static int qsort_comparison_function_int16(const void *a, const void *b)
static int read_sbr_envelope(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
static void skip_bits(GetBitContext *s, int n)
#define SBR_VLC_ROW(name)
int e_a[2]
l_APrev and l_A
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
unsigned bs_interpol_freq
AAC_SIGNE n_master
The number of frequency bands in f_master.
unsigned bs_add_harmonic_flag
static int read_sbr_channel_pair_element(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
@ T_HUFFMAN_ENV_BAL_3_0DB
AAC_FLOAT noise_facs[3][5]
static void sbr_hf_assemble(float Y1[38][64][2], const float X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Assembling HF Signals (14496-3 sp04 p220)
static INTFLOAT sbr_qmf_window_ds[320]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_PROFILE_AAC_HE_V2
static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
Derived Frequency Band Tables (14496-3 sp04 p197)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static const int8_t sbr_offset[6][16]
uint16_t f_tablenoise[6]
Frequency borders for noise floors.
void AAC_RENAME() ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac, INTFLOAT *L, INTFLOAT *R)
Apply one SBR element to one AAC element.
AAC_SIGNE n_lim
Number of limiter bands.
@ T_HUFFMAN_NOISE_BAL_3_0DB
uint8_t env_facs_q[6][48]
Envelope scalefactors.
uint16_t f_tablelow[25]
Frequency borders for low resolution SBR.
static const SoftFloat FLOAT_0
0.0
static int read_sbr_single_channel_element(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
uint16_t f_tablelim[30]
Frequency borders for the limiter.
static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr, SpectrumParameters *spectrum)
Master Frequency Band Table (14496-3 sp04 p194)
uint8_t bs_add_harmonic[48]
static unsigned int get_bits1(GetBitContext *s)
aacsbr functions pointers
static int fixed_log(int x)
static int sbr_mapping(AACContext *ac, SpectralBandReplication *sbr, SBRData *ch_data, int e_a[2])
High Frequency Adjustment (14496-3 sp04 p217) and Mapping (14496-3 sp04 p217)
#define SBR_SYNTHESIS_BUF_SIZE
int AAC_RENAME() ff_decode_sbr_extension(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb_host, int crc, int cnt, int id_aac)
Decode Spectral Band Replication extension data; reference: table 4.55.
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
uint8_t s_indexmapped[8][48]
static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read how the envelope and noise floor data is delta coded.
unsigned bs_smoothing_mode
static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64], const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2], const INTFLOAT X_low[32][40][2], int ch)
Generate the subband filtered lowband.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Spectral Band Replication header - spectrum parameters that invoke a reset if they differ from the pr...
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
uint16_t f_master[49]
The master QMF frequency grouping.
static void sbr_qmf_analysis(AVFloatDSPContext *dsp, FFTContext *mdct, SBRDSPContext *sbrdsp, const INTFLOAT *in, INTFLOAT *x, INTFLOAT z[320], INTFLOAT W[2][32][32][2], int buf_idx)
Analysis QMF Bank (14496-3 sp04 p206)
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats.
#define SBR_INIT_VLC_STATIC(num, size)
static void sbr_turnoff(SpectralBandReplication *sbr)
Places SBR in pure upsampling mode.
Spectral Band Replication.
@ F_HUFFMAN_ENV_BAL_3_0DB
uint8_t bs_invf_mode[2][5]
av_cold void AAC_RENAME() ff_ps_ctx_init(PSContext *ps)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
void ff_aacsbr_func_ptr_init_mips(AACSBRContext *c)
AAC_SIGNE n_q
Number of noise floor bands.
uint8_t patch_start_subband[6]
static const int CONST_076923
@ T_HUFFMAN_ENV_BAL_1_5DB
static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int bs_extension_id, int *num_bits_left)
void AAC_RENAME() ff_sbrdsp_init(SBRDSPContext *s)
static void aacsbr_func_ptr_init(AACSBRContext *c)
static const int CONST_RECIP_LN2
#define i(width, name, range_min, range_max)
static const int8_t ceil_log2[]
ceil(log2(index+1))
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Spectral Band Replication per channel data.
static int read_sbr_noise(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
void(* vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len)
Calculate the entry wise product of two vectors of floats, add a third vector of floats and store the...
static int in_table_int16(const int16_t *table, int last_el, int16_t needle)
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
Limiter Frequency Band Table (14496-3 sp04 p198)
OutputConfiguration oc[2]
static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read inverse filtering data.
static int array[MAX_W *MAX_W]
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
static const int8_t vlc_sbr_lav[10]
static int array_min_int16(const int16_t *array, int nel)
static av_cold void aacsbr_tableinit(void)
main external API structure.
av_cold void AAC_RENAME() ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr, int id_aac)
Initialize one SBR context.
static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int id_aac)
int ps
-1 implicit, 1 presence
static void sbr_env_estimate(AAC_FLOAT(*e_curr)[48], INTFLOAT X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data)
Estimation of current envelope (14496-3 sp04 p218)
uint8_t t_q[3]
Noise time borders.
SpectrumParameters spectrum_params
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
@ F_HUFFMAN_ENV_BAL_1_5DB
static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx)
Generate the subband filtered lowband.
static const INTFLOAT sbr_qmf_window_us[640]
uint16_t f_tablehigh[49]
Frequency borders for high resolution SBR.
uint8_t noise_facs_q[3][5]
Noise scalefactors.
static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr, INTFLOAT X_high[64][40][2], const INTFLOAT X_low[32][40][2], const INTFLOAT(*alpha0)[2], const INTFLOAT(*alpha1)[2], const INTFLOAT bw_array[5], const uint8_t *t_env, int bs_num_env)
High Frequency Generator (14496-3 sp04 p215)
static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Calculation of levels of additional HF signal components (14496-3 sp04 p219) and Calculation of gain ...
unsigned bs_limiter_bands
uint8_t patch_num_subbands[6]
#define avpriv_request_sample(...)
AAC_FLOAT(* sum_square)(INTFLOAT(*x)[2], int n)
#define ENVELOPE_ADJUSTMENT_OFFSET
int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb, PSCommonContext *ps, int bits_left)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int AAC_RENAME() ff_ps_apply(AVCodecContext *avctx, PSContext *ps, INTFLOAT L[2][38][64], INTFLOAT R[2][38][64], int top)
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec, int elements)
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)