40 for (n = 1; n < 320; n++)
45 for (n = 0; n < 320; n++)
52 const void *sbr_codes, *sbr_bits;
53 const unsigned int table_size, elem_size;
98 if(sbr->mdct.mdct_bits)
100 sbr->kx[0] = sbr->kx[1];
101 sbr->id_aac = id_aac;
123 return *(
const int16_t *)a - *(
const int16_t *)
b;
129 for (i = 0; i <= last_el; i++)
130 if (table[i] == needle)
140 static const INTFLOAT bands_warped[3] = {
Q23(1.32715174233856803909
f),
141 Q23(1.18509277094158210129
f),
142 Q23(1.11987160404675912501
f) };
144 int16_t patch_borders[7];
147 patch_borders[0] = sbr->
kx[1];
154 memcpy(sbr->
f_tablelim + sbr->
n[0] + 1, patch_borders + 1,
155 (sbr->
num_patches - 1) *
sizeof(patch_borders[0]));
162 while (out < sbr->f_tablelim + sbr->
n_lim) {
164 if ((*in << 23) >= *
out * lim_bands_per_octave_warped) {
166 if (*in >= *
out * lim_bands_per_octave_warped) {
169 }
else if (*in == *
out ||
210 if (bs_header_extra_1) {
224 if (bs_header_extra_2) {
244 int i,
min = array[0];
245 for (i = 1; i < nel; i++)
246 min =
FFMIN(array[i], min);
257 if (bs_xover_band >= n_master) {
259 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
270 unsigned int temp, max_qmf_subbands = 0;
271 unsigned int start_min, stop_min;
273 const int8_t *sbr_offset_ptr;
289 case 44100:
case 48000:
case 64000:
292 case 88200:
case 96000:
case 128000:
case 176400:
case 192000:
297 "Unsupported sample rate for SBR: %d\n", sbr->
sample_rate);
314 sbr->
k[2] = stop_min;
318 sbr->
k[2] += stop_dk[k];
320 sbr->
k[2] = 2*sbr->
k[0];
322 sbr->
k[2] = 3*sbr->
k[0];
328 sbr->
k[2] =
FFMIN(64, sbr->
k[2]);
332 max_qmf_subbands = 48;
334 max_qmf_subbands = 35;
336 max_qmf_subbands = 32;
340 if (sbr->
k[2] - sbr->
k[0] > max_qmf_subbands) {
342 "Invalid bitstream, too many QMF subbands: %d\n", sbr->
k[2] - sbr->
k[0]);
350 sbr->
n_master = ((sbr->
k[2] - sbr->
k[0] + (dk&2)) >> dk) << 1;
354 for (k = 1; k <= sbr->
n_master; k++)
357 k2diff = sbr->
k[2] - sbr->
k[0] - sbr->
n_master * dk;
366 for (k = 1; k <= sbr->
n_master; k++)
371 int two_regions, num_bands_0;
372 int vdk0_max, vdk1_min;
378 if (49 * sbr->
k[2] > 110 * sbr->
k[0]) {
380 sbr->
k[1] = 2 * sbr->
k[0];
383 sbr->
k[1] = sbr->
k[2];
387 tmp = (sbr->
k[1] << 23) / sbr->
k[0];
388 while (tmp < 0x40000000) {
394 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
395 num_bands_0 = ((tmp + 0x400000) >> 23) * 2;
397 num_bands_0 =
lrintf(half_bands *
log2f(sbr->
k[1] / (
float)sbr->
k[0])) * 2;
400 if (num_bands_0 <= 0) {
410 vdk0_max = vk0[num_bands_0];
413 for (k = 1; k <= num_bands_0; k++) {
426 tmp = (sbr->
k[2] << 23) / sbr->
k[1];
428 while (tmp < 0x40000000) {
434 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
437 num_bands_1 = ((tmp + 0x400000) >> 23) * 2;
439 float invwarp = spectrum->
bs_alter_scale ? 0.76923076923076923077f
441 int num_bands_1 =
lrintf(half_bands * invwarp *
442 log2f(sbr->
k[2] / (
float)sbr->
k[1])) * 2;
448 if (vdk1_min < vdk0_max) {
451 change =
FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
453 vk1[num_bands_1] -= change;
459 for (k = 1; k <= num_bands_1; k++) {
467 sbr->
n_master = num_bands_0 + num_bands_1;
471 (num_bands_0 + 1) *
sizeof(sbr->
f_master[0]));
472 memcpy(&sbr->
f_master[num_bands_0 + 1], vk1 + 1,
473 num_bands_1 *
sizeof(sbr->
f_master[0]));
489 int i, k, last_k = -1, last_msb = -1, sb = 0;
491 int usb = sbr->
kx[1];
496 if (goal_sb < sbr->kx[1] + sbr->
m[1]) {
497 for (k = 0; sbr->
f_master[k] < goal_sb; k++) ;
503 if (k == last_k && msb == last_msb) {
509 for (i = k; i == k || sb > (sbr->
k[0] - 1 + msb - odd); i--) {
511 odd = (sb + sbr->
k[0]) & 1;
535 }
while (sb != sbr->
kx[1] + sbr->
m[1]);
553 sbr->
n[0] = (sbr->
n[1] + 1) >> 1;
556 (sbr->
n[1] + 1) *
sizeof(sbr->
f_master[0]));
561 if (sbr->
kx[1] + sbr->
m[1] > 64) {
563 "Stop frequency border too high: %d\n", sbr->
kx[1] + sbr->
m[1]);
566 if (sbr->
kx[1] > 32) {
572 temp = sbr->
n[1] & 1;
573 for (k = 1; k <= sbr->
n[0]; k++)
576 temp = (sbr->
k[2] << 23) / sbr->
kx[1];
577 while (temp < 0x40000000) {
585 sbr->
n_q = (temp + 0x400000) >> 23;
590 log2f(sbr->
k[2] / (
float)sbr->
kx[1])));
601 for (k = 1; k <= sbr->
n_q; k++) {
602 temp += (sbr->
n[0] -
temp) / (sbr->
n_q + 1 - k);
637 int abs_bord_trail = 16;
638 int num_rel_lead, num_rel_trail;
639 unsigned bs_num_env_old = ch_data->
bs_num_env;
640 int bs_frame_class, bs_num_env;
646 switch (bs_frame_class =
get_bits(gb, 2)) {
649 if (bs_num_env > 4) {
651 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
661 ch_data->
t_env[0] = 0;
664 abs_bord_trail = (abs_bord_trail + (ch_data->
bs_num_env >> 1)) /
666 for (i = 0; i < num_rel_lead; i++)
667 ch_data->
t_env[i + 1] = ch_data->
t_env[i] + abs_bord_trail;
677 ch_data->
t_env[0] = 0;
680 for (i = 0; i < num_rel_trail; i++)
695 for (i = 0; i < num_rel_lead; i++)
707 bs_num_env = num_rel_lead + num_rel_trail + 1;
709 if (bs_num_env > 5) {
711 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
719 for (i = 0; i < num_rel_lead; i++)
721 for (i = 0; i < num_rel_trail; i++)
735 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
741 if (ch_data->
t_env[i-1] >= ch_data->
t_env[i]) {
749 ch_data->
t_q[0] = ch_data->
t_env[0];
760 else if (bs_pointer == 1)
763 idx = bs_pointer - 1;
765 ch_data->
t_q[1] = ch_data->
t_env[idx];
768 ch_data->
e_a[0] = -(ch_data->
e_a[1] != bs_num_env_old);
769 ch_data->
e_a[1] = -1;
773 ch_data->
e_a[1] = bs_pointer - 1;
787 memcpy(dst->
t_q, src->
t_q,
sizeof(dst->
t_q));
792 dst->
e_a[1] = src->
e_a[1];
810 for (i = 0; i < sbr->
n_q; i++)
819 VLC_TYPE (*t_huff)[2], (*f_huff)[2];
822 const int odd = sbr->
n[1] & 1;
858 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
866 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
875 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
876 k = j ? 2*j - odd : 0;
886 for (j = 1; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
907 VLC_TYPE (*t_huff)[2], (*f_huff)[2];
925 for (j = 0; j < sbr->
n_q; j++) {
934 for (j = 1; j < sbr->
n_q; j++) {
952 int bs_extension_id,
int *num_bits_left)
954 switch (bs_extension_id) {
957 av_log(ac->
avctx,
AV_LOG_ERROR,
"Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
967 if (bs_extension_id || *num_bits_left > 16 ||
show_bits(gb, *num_bits_left))
1071 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1076 int num_bits_left =
get_bits(gb, 4);
1077 if (num_bits_left == 15)
1080 num_bits_left <<= 3;
1081 while (num_bits_left > 7) {
1085 if (num_bits_left < 0) {
1088 if (num_bits_left > 0)
1103 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1119 unsigned int num_sbr_bits = 0, num_align_bits;
1120 unsigned bytes_read;
1126 if (!sbr->sample_rate)
1127 sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1128 if (!ac->oc[1].m4ac.ext_sample_rate)
1129 ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1137 sbr->kx[0] = sbr->kx[1];
1138 sbr->m[0] = sbr->m[1];
1139 sbr->kx_and_m_pushed = 1;
1151 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1152 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1154 if (bytes_read > cnt) {
1156 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1168 #ifndef sbr_qmf_analysis 1181 memcpy(x , x+1024, (320-32)*
sizeof(x[0]));
1182 memcpy(x+288, in, 1024*
sizeof(x[0]));
1183 for (i = 0; i < 32; i++) {
1187 sbrdsp->qmf_pre_shuffle(z);
1189 for (j = 64; j < 128; j++) {
1192 "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1195 }
else if (z[j] < -(1<<24)) {
1197 "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1204 sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
1214 #ifndef sbr_qmf_synthesis 1223 INTFLOAT *
v0,
int *v_off,
const unsigned int div)
1227 const int step = 128 >> div;
1229 for (i = 0; i < 32; i++) {
1230 if (*v_off < step) {
1231 int saved_samples = (1280 - 128) >> div;
1239 for (n = 0; n < 32; n++) {
1240 X[0][
i][ n] = -X[0][
i][n];
1241 X[0][
i][32+n] = X[1][
i][31-n];
1243 mdct->
imdct_half(mdct, mdct_buf[0], X[0][i]);
1244 sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1246 sbrdsp->neg_odd_64(X[1][i]);
1247 mdct->
imdct_half(mdct, mdct_buf[0], X[0][i]);
1248 mdct->
imdct_half(mdct, mdct_buf[1], X[1][i]);
1249 sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1251 dsp->
vector_fmul (out, v , sbr_qmf_window , 64 >> div);
1252 dsp->
vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div);
1253 dsp->
vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div);
1254 dsp->
vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div);
1255 dsp->
vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div);
1256 dsp->
vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div);
1257 dsp->
vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div);
1258 dsp->
vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div);
1259 dsp->
vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div);
1260 dsp->
vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div);
1272 const int t_HFGen = 8;
1274 memset(X_low, 0, 32*
sizeof(*X_low));
1275 for (k = 0; k < sbr->
kx[1]; k++) {
1276 for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1277 X_low[k][
i][0] = W[buf_idx][i - t_HFGen][k][0];
1278 X_low[k][
i][1] = W[buf_idx][i - t_HFGen][k][1];
1281 buf_idx = 1-buf_idx;
1282 for (k = 0; k < sbr->
kx[0]; k++) {
1283 for (i = 0; i < t_HFGen; i++) {
1284 X_low[k][
i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
1285 X_low[k][
i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
1310 "ERROR : no subband found for frequency %d\n", k);
1316 alpha0[p], alpha1[p], bw_array[g],
1317 2 * t_env[0], 2 * t_env[bs_num_env]);
1320 if (k < sbr->m[1] + sbr->
kx[1])
1321 memset(X_high + k, 0, (sbr->
m[1] + sbr->
kx[1] - k) *
sizeof(*X_high));
1329 const INTFLOAT X_low[32][40][2],
int ch)
1334 memset(X, 0, 2*
sizeof(*X));
1335 for (k = 0; k < sbr->
kx[0]; k++) {
1336 for (i = 0; i < i_Temp; i++) {
1341 for (; k < sbr->
kx[0] + sbr->
m[0]; k++) {
1342 for (i = 0; i < i_Temp; i++) {
1343 X[0][
i][k] = Y0[i + i_f][k][0];
1344 X[1][
i][k] = Y0[i + i_f][k][1];
1348 for (k = 0; k < sbr->
kx[1]; k++) {
1349 for (i = i_Temp; i < 38; i++) {
1354 for (; k < sbr->
kx[1] + sbr->
m[1]; k++) {
1355 for (i = i_Temp; i < i_f; i++) {
1356 X[0][
i][k] = Y1[
i][k][0];
1357 X[1][
i][k] = Y1[
i][k][1];
1373 const unsigned int ilim = sbr->
n[ch_data->
bs_freq_res[e + 1]];
1377 if (sbr->
kx[1] != table[0]) {
1379 "Derived frequency tables were not regenerated.\n");
1383 for (i = 0; i < ilim; i++)
1384 for (m = table[i]; m < table[i + 1]; m++)
1389 for (i = 0; i < sbr->
n_q; i++)
1390 for (m = sbr->
f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1393 for (i = 0; i < sbr->
n[1]; i++) {
1395 const unsigned int m_midpoint =
1399 (e >= e_a[1] || (ch_data->
s_indexmapped[0][m_midpoint - sbr->
kx[1]] == 1));
1403 for (i = 0; i < ilim; i++) {
1404 int additional_sinusoid_present = 0;
1405 for (m = table[i]; m < table[i + 1]; m++) {
1407 additional_sinusoid_present = 1;
1411 memset(&sbr->
s_mapped[e][table[i] - sbr->
kx[1]], additional_sinusoid_present,
1412 (table[i + 1] - table[i]) *
sizeof(sbr->
s_mapped[e][0]));
1425 int kx1 = sbr->
kx[1];
1432 const float recip_env_size = 0.5f / (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1437 for (m = 0; m < sbr->
m[1]; m++) {
1440 e_curr[e][m] =
av_mul_sf(sum, recip_env_size);
1442 e_curr[e][m] = sum * recip_env_size;
1450 const int env_size = 2 * (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1455 for (p = 0; p < sbr->
n[ch_data->
bs_freq_res[e + 1]]; p++) {
1458 const SoftFloat den =
av_int2sf(0x20000000 / (env_size * (table[p + 1] - table[p])), 29);
1459 for (k = table[p]; k < table[p + 1]; k++) {
1465 const int den = env_size * (table[p + 1] - table[p]);
1467 for (k = table[p]; k < table[p + 1]; k++) {
1472 for (k = table[p]; k < table[p + 1]; k++) {
1473 e_curr[e][k - kx1] = sum;
1483 int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1485 int nch = (id_aac ==
TYPE_CPE) ? 2 : 1;
1488 if (id_aac != sbr->id_aac) {
1490 "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
1494 if (sbr->start && !sbr->ready_for_dequant) {
1496 "No quantized data read for sbr_dequant.\n");
1500 if (!sbr->kx_and_m_pushed) {
1501 sbr->kx[0] = sbr->kx[1];
1502 sbr->m[0] = sbr->m[1];
1504 sbr->kx_and_m_pushed = 0;
1509 sbr->ready_for_dequant = 0;
1511 for (ch = 0; ch < nch; ch++) {
1513 sbr_qmf_analysis(ac->fdsp, &sbr->mdct_ana, &sbr->dsp, ch ?
R : L, sbr->data[ch].analysis_filterbank_samples,
1514 (
INTFLOAT*)sbr->qmf_filter_scratch,
1515 sbr->data[ch].W, sbr->data[ch].Ypos);
1516 sbr->c.sbr_lf_gen(ac, sbr, sbr->X_low,
1517 (
const INTFLOAT (*)[32][32][2]) sbr->data[ch].W,
1518 sbr->data[ch].Ypos);
1519 sbr->data[ch].Ypos ^= 1;
1521 sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
1522 (
const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]);
1526 (
const INTFLOAT (*)[40][2]) sbr->X_low,
1527 (
const INTFLOAT (*)[2]) sbr->alpha0,
1528 (
const INTFLOAT (*)[2]) sbr->alpha1,
1529 sbr->data[ch].bw_array, sbr->data[ch].t_env,
1530 sbr->data[ch].bs_num_env);
1533 err =
sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1537 sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
1538 (
const INTFLOAT (*)[40][2]) sbr->X_high,
1539 sbr, &sbr->data[ch],
1545 sbr->c.sbr_x_gen(sbr, sbr->X[ch],
1546 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos],
1547 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[ sbr->data[ch].Ypos],
1548 (
const INTFLOAT (*)[40][2]) sbr->X_low, ch);
1551 if (ac->oc[1].m4ac.ps == 1) {
1552 if (sbr->ps.start) {
1555 memcpy(sbr->X[1], sbr->X[0],
sizeof(sbr->X[0]));
1561 L, sbr->X[0], sbr->qmf_filter_scratch,
1562 sbr->data[0].synthesis_filterbank_samples,
1563 &sbr->data[0].synthesis_filterbank_samples_offset,
1567 R, sbr->X[1], sbr->qmf_filter_scratch,
1568 sbr->data[1].synthesis_filterbank_samples,
1569 &sbr->data[1].synthesis_filterbank_samples_offset,
uint8_t s_indexmapped[8][48]
unsigned bs_add_harmonic_flag
void AAC_RENAME() ff_sbrdsp_init(SBRDSPContext *s)
static int qsort_comparison_function_int16(const void *a, const void *b)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int id_aac)
static int array_min_int16(const int16_t *array, int nel)
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 const int8_t vlc_sbr_lav[10]
int(* sbr_lf_gen)(AACContext *ac, SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx)
unsigned bs_smoothing_mode
static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
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 skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define avpriv_request_sample(...)
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)
int e_a[2]
l_APrev and l_A
int AAC_RENAME() ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host, PSContext *ps, int bits_left)
static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read inverse filtering data.
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
uint8_t noise_facs_q[3][5]
Noise scalefactors.
#define FF_PROFILE_AAC_HE_V2
SpectrumParameters spectrum_params
int AAC_RENAME() ff_ps_apply(AVCodecContext *avctx, PSContext *ps, INTFLOAT L[2][38][64], INTFLOAT R[2][38][64], int top)
static const SoftFloat FLOAT_0
0.0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static const int8_t sbr_offset[6][16]
AAC_FLOAT noise_facs[3][5]
AAC_SIGNE n_lim
Number of limiter bands.
#define ENVELOPE_ADJUSTMENT_OFFSET
static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
uint16_t f_tablehigh[49]
Frequency borders for high resolution SBR.
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...
void ff_aacsbr_func_ptr_init_mips(AACSBRContext *c)
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 int get_bits_count(const GetBitContext *s)
static INTFLOAT sbr_qmf_window_us[640]
#define AV_LOG_VERBOSE
Detailed information.
av_cold void AAC_RENAME() ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
Close one SBR context.
static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
Derived Frequency Band Tables (14496-3 sp04 p197)
static int fixed_log(int x)
static int read_sbr_envelope(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
uint8_t patch_num_subbands[6]
static const uint16_t table[]
uint16_t f_tablenoise[6]
Frequency borders for noise floors.
#define SBR_INIT_VLC_STATIC(num, size)
static void copy_sbr_grid(SBRData *dst, const SBRData *src)
uint8_t t_q[3]
Noise time borders.
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint16_t f_tablelow[25]
Frequency borders for low resolution SBR.
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...
Spectral Band Replication header - spectrum parameters that invoke a reset if they differ from the pr...
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
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)
av_cold void AAC_RENAME() ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr, int id_aac)
Initialize one SBR context.
unsigned bs_interpol_freq
uint8_t env_facs_q[6][48]
Envelope scalefactors.
AAC_FLOAT(* sum_square)(INTFLOAT(*x)[2], int n)
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
static int read_sbr_channel_pair_element(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
static const ElemCat * elements[ELEMENT_COUNT]
unsigned bs_limiter_gains
static const int CONST_RECIP_LN2
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(* sbr_hf_inverse_filter)(SBRDSPContext *dsp, INTFLOAT(*alpha0)[2], INTFLOAT(*alpha1)[2], const INTFLOAT X_low[32][40][2], int k0)
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
static void aacsbr_func_ptr_init(AACSBRContext *c)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static int in_table_int16(const int16_t *table, int last_el, int16_t needle)
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)
av_cold void AAC_RENAME() ff_ps_init(void)
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 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 ...
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)
static void sbr_turnoff(SpectralBandReplication *sbr)
Places SBR in pure upsampling mode.
#define SBR_SYNTHESIS_BUF_SIZE
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
static const int8_t ceil_log2[]
ceil(log2(index+1))
typedef void(RENAME(mix_any_func_type))
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.
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.
main external API structure.
static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read how the envelope and noise floor data is delta coded.
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static unsigned int get_bits1(GetBitContext *s)
static const int CONST_076923
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static void skip_bits(GetBitContext *s, int n)
static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec, int elements)
static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int bs_extension_id, int *num_bits_left)
static int read_sbr_single_channel_element(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr, SpectrumParameters *spectrum)
Master Frequency Band Table (14496-3 sp04 p194)
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
av_cold void AAC_RENAME() ff_ps_ctx_init(PSContext *ps)
AAC_FLOAT env_facs[6][48]
AAC_SIGNE n_master
The number of frequency bands in f_master.
static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
Limiter Frequency Band Table (14496-3 sp04 p198)
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
uint16_t f_master[49]
The master QMF frequency grouping.
uint8_t bs_invf_mode[2][5]
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
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.
OutputConfiguration oc[2]
static av_cold void aacsbr_tableinit(void)
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
uint8_t patch_start_subband[6]
uint8_t t_env[8]
Envelope time borders.
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...
aacsbr functions pointers
static INTFLOAT sbr_qmf_window_ds[320]
< window coefficients for analysis/synthesis QMF banks
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Spectral Band Replication per channel data.
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
#define SBR_VLC_ROW(name)
unsigned bs_limiter_bands
static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
VLC_TYPE(* table)[2]
code, bits
void(* sbr_hf_assemble)(INTFLOAT Y1[38][64][2], const INTFLOAT X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
static int array[MAX_W *MAX_W]
int ps
-1 implicit, 1 presence
AAC_SIGNE n_q
Number of noise floor bands.
Spectral Band Replication.
static int read_sbr_noise(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
av_cold void AAC_RENAME() ff_aac_sbr_init(void)
Initialize SBR.
uint8_t bs_add_harmonic[48]
#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...
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
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...