38 const void *sbr_codes, *sbr_bits;
39 const unsigned int table_size, elem_size;
84 if(sbr->mdct.mdct_bits)
86 sbr->kx[0] = sbr->kx[1];
108 return *(
const int16_t *)a - *(
const int16_t *)
b;
114 for (i = 0; i <= last_el; i++)
115 if (table[i] == needle)
125 static const INTFLOAT bands_warped[3] = {
Q23(1.32715174233856803909f),
126 Q23(1.18509277094158210129f),
127 Q23(1.11987160404675912501f) };
129 int16_t patch_borders[7];
132 patch_borders[0] = sbr->
kx[1];
139 memcpy(sbr->
f_tablelim + sbr->
n[0] + 1, patch_borders + 1,
140 (sbr->
num_patches - 1) *
sizeof(patch_borders[0]));
147 while (out < sbr->f_tablelim + sbr->
n_lim) {
149 if ((*in << 23) >= *
out * lim_bands_per_octave_warped) {
151 if (*in >= *
out * lim_bands_per_octave_warped) {
154 }
else if (*in == *
out ||
195 if (bs_header_extra_1) {
209 if (bs_header_extra_2) {
229 int i,
min = array[0];
230 for (i = 1; i < nel; i++)
231 min =
FFMIN(array[i], min);
242 if (bs_xover_band >= n_master) {
244 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
255 unsigned int temp, max_qmf_subbands = 0;
256 unsigned int start_min, stop_min;
258 const int8_t *sbr_offset_ptr;
281 case 44100:
case 48000:
case 64000:
284 case 88200:
case 96000:
case 128000:
case 176400:
case 192000:
289 "Unsupported sample rate for SBR: %d\n", sbr->
sample_rate);
299 sbr->
k[2] = stop_min;
303 sbr->
k[2] += stop_dk[k];
305 sbr->
k[2] = 2*sbr->
k[0];
307 sbr->
k[2] = 3*sbr->
k[0];
313 sbr->
k[2] =
FFMIN(64, sbr->
k[2]);
317 max_qmf_subbands = 48;
319 max_qmf_subbands = 35;
321 max_qmf_subbands = 32;
325 if (sbr->
k[2] - sbr->
k[0] > max_qmf_subbands) {
327 "Invalid bitstream, too many QMF subbands: %d\n", sbr->
k[2] - sbr->
k[0]);
335 sbr->
n_master = ((sbr->
k[2] - sbr->
k[0] + (dk&2)) >> dk) << 1;
339 for (k = 1; k <= sbr->
n_master; k++)
342 k2diff = sbr->
k[2] - sbr->
k[0] - sbr->
n_master * dk;
351 for (k = 1; k <= sbr->
n_master; k++)
356 int two_regions, num_bands_0;
357 int vdk0_max, vdk1_min;
363 if (49 * sbr->
k[2] > 110 * sbr->
k[0]) {
365 sbr->
k[1] = 2 * sbr->
k[0];
368 sbr->
k[1] = sbr->
k[2];
372 tmp = (sbr->
k[1] << 23) / sbr->
k[0];
373 while (tmp < 0x40000000) {
379 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
380 num_bands_0 = ((tmp + 0x400000) >> 23) * 2;
382 num_bands_0 =
lrintf(half_bands *
log2f(sbr->
k[1] / (
float)sbr->
k[0])) * 2;
385 if (num_bands_0 <= 0) {
395 vdk0_max = vk0[num_bands_0];
398 for (k = 1; k <= num_bands_0; k++) {
411 tmp = (sbr->
k[2] << 23) / sbr->
k[1];
413 while (tmp < 0x40000000) {
419 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
421 tmp = (int)(((int64_t)tmp *
CONST_076923 + 0x40000000) >> 31);
422 num_bands_1 = ((tmp + 0x400000) >> 23) * 2;
424 float invwarp = spectrum->
bs_alter_scale ? 0.76923076923076923077f
426 int num_bands_1 =
lrintf(half_bands * invwarp *
427 log2f(sbr->
k[2] / (
float)sbr->
k[1])) * 2;
433 if (vdk1_min < vdk0_max) {
436 change =
FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
438 vk1[num_bands_1] -= change;
444 for (k = 1; k <= num_bands_1; k++) {
452 sbr->
n_master = num_bands_0 + num_bands_1;
456 (num_bands_0 + 1) *
sizeof(sbr->
f_master[0]));
457 memcpy(&sbr->
f_master[num_bands_0 + 1], vk1 + 1,
458 num_bands_1 *
sizeof(sbr->
f_master[0]));
474 int i, k, last_k = -1, last_msb = -1, sb = 0;
476 int usb = sbr->
kx[1];
481 if (goal_sb < sbr->kx[1] + sbr->
m[1]) {
482 for (k = 0; sbr->
f_master[k] < goal_sb; k++) ;
488 if (k == last_k && msb == last_msb) {
494 for (i = k; i == k || sb > (sbr->
k[0] - 1 + msb - odd); i--) {
496 odd = (sb + sbr->
k[0]) & 1;
520 }
while (sb != sbr->
kx[1] + sbr->
m[1]);
538 sbr->
n[0] = (sbr->
n[1] + 1) >> 1;
541 (sbr->
n[1] + 1) *
sizeof(sbr->
f_master[0]));
546 if (sbr->
kx[1] + sbr->
m[1] > 64) {
548 "Stop frequency border too high: %d\n", sbr->
kx[1] + sbr->
m[1]);
551 if (sbr->
kx[1] > 32) {
557 temp = sbr->
n[1] & 1;
558 for (k = 1; k <= sbr->
n[0]; k++)
561 temp = (sbr->
k[2] << 23) / sbr->
kx[1];
562 while (temp < 0x40000000) {
570 sbr->
n_q = (temp + 0x400000) >> 23;
575 log2f(sbr->
k[2] / (
float)sbr->
kx[1])));
585 for (k = 1; k <= sbr->
n_q; k++) {
586 temp += (sbr->
n[0] -
temp) / (sbr->
n_q + 1 - k);
605 for (i = 0; i < elements; i++) {
621 int abs_bord_trail = 16;
622 int num_rel_lead, num_rel_trail;
623 unsigned bs_num_env_old = ch_data->
bs_num_env;
624 int bs_frame_class, bs_num_env;
630 switch (bs_frame_class =
get_bits(gb, 2)) {
633 if (bs_num_env > 4) {
635 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
645 ch_data->
t_env[0] = 0;
648 abs_bord_trail = (abs_bord_trail + (ch_data->
bs_num_env >> 1)) /
650 for (i = 0; i < num_rel_lead; i++)
651 ch_data->
t_env[i + 1] = ch_data->
t_env[i] + abs_bord_trail;
661 ch_data->
t_env[0] = 0;
664 for (i = 0; i < num_rel_trail; i++)
679 for (i = 0; i < num_rel_lead; i++)
691 bs_num_env = num_rel_lead + num_rel_trail + 1;
693 if (bs_num_env > 5) {
695 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
703 for (i = 0; i < num_rel_lead; i++)
705 for (i = 0; i < num_rel_trail; i++)
719 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
725 if (ch_data->
t_env[i-1] >= ch_data->
t_env[i]) {
733 ch_data->
t_q[0] = ch_data->
t_env[0];
744 else if (bs_pointer == 1)
747 idx = bs_pointer - 1;
749 ch_data->
t_q[1] = ch_data->
t_env[idx];
752 ch_data->
e_a[0] = -(ch_data->
e_a[1] != bs_num_env_old);
753 ch_data->
e_a[1] = -1;
757 ch_data->
e_a[1] = bs_pointer - 1;
771 memcpy(dst->
t_q, src->
t_q,
sizeof(dst->
t_q));
776 dst->
e_a[1] = src->
e_a[1];
794 for (i = 0; i < sbr->
n_q; i++)
803 VLC_TYPE (*t_huff)[2], (*f_huff)[2];
806 const int odd = sbr->
n[1] & 1;
843 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++)
846 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
851 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
852 k = j ? 2*j - odd : 0;
858 for (j = 1; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++)
859 ch_data->
env_facs[i + 1][j].mant = ch_data->
env_facs[i + 1][j - 1].mant + delta * (
get_vlc2(gb, f_huff, 9, 3) - f_lav);
867 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++)
870 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;
882 for (j = 1; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++)
897 VLC_TYPE (*t_huff)[2], (*f_huff)[2];
916 for (j = 0; j < sbr->
n_q; j++)
920 for (j = 1; j < sbr->
n_q; j++)
927 for (j = 0; j < sbr->
n_q; j++)
931 for (j = 1; j < sbr->
n_q; j++)
944 int bs_extension_id,
int *num_bits_left)
946 switch (bs_extension_id) {
949 av_log(ac->
avctx,
AV_LOG_ERROR,
"Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
965 if (bs_extension_id || *num_bits_left > 16 ||
show_bits(gb, *num_bits_left))
1055 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1060 int num_bits_left =
get_bits(gb, 4);
1061 if (num_bits_left == 15)
1064 num_bits_left <<= 3;
1065 while (num_bits_left > 7) {
1069 if (num_bits_left < 0) {
1072 if (num_bits_left > 0)
1087 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1103 unsigned int num_sbr_bits = 0, num_align_bits;
1104 unsigned bytes_read;
1110 if (!sbr->sample_rate)
1111 sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1112 if (!ac->oc[1].m4ac.ext_sample_rate)
1113 ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1121 sbr->kx[0] = sbr->kx[1];
1122 sbr->m[0] = sbr->m[1];
1123 sbr->kx_and_m_pushed = 1;
1135 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1136 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1138 if (bytes_read > cnt) {
1140 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1151 #ifndef sbr_qmf_analysis
1164 memcpy(x , x+1024, (320-32)*
sizeof(x[0]));
1165 memcpy(x+288, in, 1024*
sizeof(x[0]));
1166 for (i = 0; i < 32; i++) {
1170 sbrdsp->qmf_pre_shuffle(z);
1172 for (j = 64; j < 128; j++) {
1175 "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1178 }
else if (z[j] < -(1<<24)) {
1180 "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1187 sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
1197 #ifndef sbr_qmf_synthesis
1206 INTFLOAT *
v0,
int *v_off,
const unsigned int div)
1210 const int step = 128 >> div;
1212 for (i = 0; i < 32; i++) {
1213 if (*v_off < step) {
1214 int saved_samples = (1280 - 128) >> div;
1222 for (n = 0; n < 32; n++) {
1223 X[0][i][
n] = -X[0][i][
n];
1224 X[0][i][32+
n] = X[1][i][31-
n];
1226 mdct->
imdct_half(mdct, mdct_buf[0], X[0][i]);
1227 sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1229 sbrdsp->neg_odd_64(X[1][i]);
1230 mdct->
imdct_half(mdct, mdct_buf[0], X[0][i]);
1231 mdct->
imdct_half(mdct, mdct_buf[1], X[1][i]);
1232 sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1234 dsp->
vector_fmul (out, v , sbr_qmf_window , 64 >> div);
1235 dsp->
vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div);
1236 dsp->
vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div);
1237 dsp->
vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div);
1238 dsp->
vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div);
1239 dsp->
vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div);
1240 dsp->
vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div);
1241 dsp->
vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div);
1242 dsp->
vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div);
1243 dsp->
vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div);
1255 const int t_HFGen = 8;
1257 memset(X_low, 0, 32*
sizeof(*X_low));
1258 for (k = 0; k < sbr->
kx[1]; k++) {
1259 for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1260 X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0];
1261 X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1];
1264 buf_idx = 1-buf_idx;
1265 for (k = 0; k < sbr->
kx[0]; k++) {
1266 for (i = 0; i < t_HFGen; i++) {
1267 X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
1268 X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
1293 "ERROR : no subband found for frequency %d\n", k);
1299 alpha0[p], alpha1[p], bw_array[g],
1300 2 * t_env[0], 2 * t_env[bs_num_env]);
1303 if (k < sbr->
m[1] + sbr->
kx[1])
1304 memset(X_high + k, 0, (sbr->
m[1] + sbr->
kx[1] - k) *
sizeof(*X_high));
1312 const INTFLOAT X_low[32][40][2],
int ch)
1317 memset(X, 0, 2*
sizeof(*X));
1318 for (k = 0; k < sbr->
kx[0]; k++) {
1319 for (i = 0; i < i_Temp; i++) {
1324 for (; k < sbr->
kx[0] + sbr->
m[0]; k++) {
1325 for (i = 0; i < i_Temp; i++) {
1326 X[0][i][k] = Y0[i + i_f][k][0];
1327 X[1][i][k] = Y0[i + i_f][k][1];
1331 for (k = 0; k < sbr->
kx[1]; k++) {
1332 for (i = i_Temp; i < 38; i++) {
1337 for (; k < sbr->
kx[1] + sbr->
m[1]; k++) {
1338 for (i = i_Temp; i < i_f; i++) {
1339 X[0][i][k] = Y1[i][k][0];
1340 X[1][i][k] = Y1[i][k][1];
1356 const unsigned int ilim = sbr->
n[ch_data->
bs_freq_res[e + 1]];
1360 if (sbr->
kx[1] != table[0]) {
1362 "Derived frequency tables were not regenerated.\n");
1366 for (i = 0; i < ilim; i++)
1367 for (m = table[i]; m < table[i + 1]; m++)
1372 for (i = 0; i < sbr->
n_q; i++)
1373 for (m = sbr->
f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1376 for (i = 0; i < sbr->
n[1]; i++) {
1378 const unsigned int m_midpoint =
1382 (e >= e_a[1] || (ch_data->
s_indexmapped[0][m_midpoint - sbr->
kx[1]] == 1));
1386 for (i = 0; i < ilim; i++) {
1387 int additional_sinusoid_present = 0;
1388 for (m = table[i]; m < table[i + 1]; m++) {
1390 additional_sinusoid_present = 1;
1394 memset(&sbr->
s_mapped[e][table[i] - sbr->
kx[1]], additional_sinusoid_present,
1395 (table[i + 1] - table[i]) *
sizeof(sbr->
s_mapped[e][0]));
1408 int kx1 = sbr->
kx[1];
1415 const float recip_env_size = 0.5f / (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1420 for (m = 0; m < sbr->
m[1]; m++) {
1423 e_curr[e][
m] =
av_mul_sf(sum, recip_env_size);
1425 e_curr[e][
m] = sum * recip_env_size;
1433 const int env_size = 2 * (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1438 for (p = 0; p < sbr->
n[ch_data->
bs_freq_res[e + 1]]; p++) {
1441 const SoftFloat den =
av_int2sf(0x20000000 / (env_size * (table[p + 1] - table[p])), 29);
1442 for (k = table[p]; k < table[p + 1]; k++) {
1448 const int den = env_size * (table[p + 1] - table[p]);
1450 for (k = table[p]; k < table[p + 1]; k++) {
1455 for (k = table[p]; k < table[p + 1]; k++) {
1456 e_curr[e][k - kx1] = sum;
1466 int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1468 int nch = (id_aac ==
TYPE_CPE) ? 2 : 1;
1471 if (id_aac != sbr->id_aac) {
1473 "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
1477 if (sbr->start && !sbr->ready_for_dequant) {
1479 "No quantized data read for sbr_dequant.\n");
1483 if (!sbr->kx_and_m_pushed) {
1484 sbr->kx[0] = sbr->kx[1];
1485 sbr->m[0] = sbr->m[1];
1487 sbr->kx_and_m_pushed = 0;
1492 sbr->ready_for_dequant = 0;
1494 for (ch = 0; ch < nch; ch++) {
1496 sbr_qmf_analysis(ac->fdsp, &sbr->mdct_ana, &sbr->dsp, ch ?
R : L, sbr->data[ch].analysis_filterbank_samples,
1497 (
INTFLOAT*)sbr->qmf_filter_scratch,
1498 sbr->data[ch].W, sbr->data[ch].Ypos);
1499 sbr->c.sbr_lf_gen(ac, sbr, sbr->X_low,
1500 (
const INTFLOAT (*)[32][32][2]) sbr->data[ch].W,
1501 sbr->data[ch].Ypos);
1502 sbr->data[ch].Ypos ^= 1;
1504 sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
1505 (
const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]);
1509 (
const INTFLOAT (*)[40][2]) sbr->X_low,
1510 (
const INTFLOAT (*)[2]) sbr->alpha0,
1511 (
const INTFLOAT (*)[2]) sbr->alpha1,
1512 sbr->data[ch].bw_array, sbr->data[ch].t_env,
1513 sbr->data[ch].bs_num_env);
1516 err =
sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1520 sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
1521 (
const INTFLOAT (*)[40][2]) sbr->X_high,
1522 sbr, &sbr->data[ch],
1528 sbr->c.sbr_x_gen(sbr, sbr->X[ch],
1529 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos],
1530 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[ sbr->data[ch].Ypos],
1531 (
const INTFLOAT (*)[40][2]) sbr->X_low, ch);
1534 if (ac->oc[1].m4ac.ps == 1) {
1535 if (sbr->ps.start) {
1538 memcpy(sbr->X[1], sbr->X[0],
sizeof(sbr->X[0]));
1544 L, sbr->X[0], sbr->qmf_filter_scratch,
1545 sbr->data[0].synthesis_filterbank_samples,
1546 &sbr->data[0].synthesis_filterbank_samples_offset,
1550 R, sbr->X[1], sbr->qmf_filter_scratch,
1551 sbr->data[1].synthesis_filterbank_samples,
1552 &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]
unsigned bs_smoothing_mode
static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
AAC_FLOAT(* sum_square)(INTFLOAT(*x)[2], int n)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
static float sbr_qmf_window_us[640]
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)
#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.
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...
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])
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)
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static const int8_t sbr_offset[6][16]
AAC_FLOAT noise_facs[3][5]
Noise scalefactors.
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 ff_aacsbr_func_ptr_init_mips(AACSBRContext *c)
static int get_bits_count(const GetBitContext *s)
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)
void(* sbr_hf_inverse_filter)(SBRDSPContext *dsp, INTFLOAT(*alpha0)[2], INTFLOAT(*alpha1)[2], const INTFLOAT X_low[32][40][2], int k0)
static int fixed_log(int x)
uint8_t patch_num_subbands[6]
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.
static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
#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...
#define FF_PROFILE_AAC_HE_V2
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use 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...
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
static const struct endianess table[]
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)
unsigned bs_interpol_freq
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 float sbr_qmf_window_ds[320]
< window coefficients for analysis/synthesis QMF banks
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)
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 ...
static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, 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))
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)
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(WINAPI *cond_broadcast)(pthread_cond_t *cond)
static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read how the envelope and noise floor data is delta coded.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
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...
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static unsigned int get_bits1(GetBitContext *s)
static const int CONST_076923
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]
Envelope scalefactors.
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 avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
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]
int(* sbr_lf_gen)(AACContext *ac, SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx)
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.
aacsbr functions pointers
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
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
int ps
-1 implicit, 1 presence
AAC_SIGNE n_q
Number of noise floor bands.
Spectral Band Replication.
static av_cold void aacsbr_tableinit(void)
av_cold void AAC_RENAME() ff_aac_sbr_init(void)
Initialize SBR.
uint8_t bs_add_harmonic[48]
av_cold void AAC_RENAME() ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr)
Initialize one SBR context.
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)