40 const void *sbr_codes, *sbr_bits;
41 const unsigned int table_size, elem_size;
86 if(sbr->mdct.mdct_bits)
88 sbr->kx[0] = sbr->kx[1];
111 return *(
const int16_t *)a - *(
const int16_t *)
b;
117 for (i = 0; i <= last_el; i++)
118 if (table[i] == needle)
128 static const INTFLOAT bands_warped[3] = {
Q23(1.32715174233856803909f),
129 Q23(1.18509277094158210129f),
130 Q23(1.11987160404675912501f) };
132 int16_t patch_borders[7];
135 patch_borders[0] = sbr->
kx[1];
142 memcpy(sbr->
f_tablelim + sbr->
n[0] + 1, patch_borders + 1,
143 (sbr->
num_patches - 1) *
sizeof(patch_borders[0]));
150 while (out < sbr->f_tablelim + sbr->
n_lim) {
152 if ((*in << 23) >= *
out * lim_bands_per_octave_warped) {
154 if (*in >= *
out * lim_bands_per_octave_warped) {
157 }
else if (*in == *
out ||
198 if (bs_header_extra_1) {
212 if (bs_header_extra_2) {
232 int i,
min = array[0];
233 for (i = 1; i < nel; i++)
234 min =
FFMIN(array[i], min);
245 if (bs_xover_band >= n_master) {
247 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
258 unsigned int temp, max_qmf_subbands = 0;
259 unsigned int start_min, stop_min;
261 const int8_t *sbr_offset_ptr;
284 case 44100:
case 48000:
case 64000:
287 case 88200:
case 96000:
case 128000:
case 176400:
case 192000:
292 "Unsupported sample rate for SBR: %d\n", sbr->
sample_rate);
302 sbr->
k[2] = stop_min;
306 sbr->
k[2] += stop_dk[k];
308 sbr->
k[2] = 2*sbr->
k[0];
310 sbr->
k[2] = 3*sbr->
k[0];
316 sbr->
k[2] =
FFMIN(64, sbr->
k[2]);
320 max_qmf_subbands = 48;
322 max_qmf_subbands = 35;
324 max_qmf_subbands = 32;
328 if (sbr->
k[2] - sbr->
k[0] > max_qmf_subbands) {
330 "Invalid bitstream, too many QMF subbands: %d\n", sbr->
k[2] - sbr->
k[0]);
338 sbr->
n_master = ((sbr->
k[2] - sbr->
k[0] + (dk&2)) >> dk) << 1;
342 for (k = 1; k <= sbr->
n_master; k++)
345 k2diff = sbr->
k[2] - sbr->
k[0] - sbr->
n_master * dk;
354 for (k = 1; k <= sbr->
n_master; k++)
359 int two_regions, num_bands_0;
360 int vdk0_max, vdk1_min;
366 if (49 * sbr->
k[2] > 110 * sbr->
k[0]) {
368 sbr->
k[1] = 2 * sbr->
k[0];
371 sbr->
k[1] = sbr->
k[2];
375 tmp = (sbr->
k[1] << 23) / sbr->
k[0];
376 while (tmp < 0x40000000) {
382 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
383 num_bands_0 = ((tmp + 0x400000) >> 23) * 2;
385 num_bands_0 =
lrintf(half_bands *
log2f(sbr->
k[1] / (
float)sbr->
k[0])) * 2;
388 if (num_bands_0 <= 0) {
398 vdk0_max = vk0[num_bands_0];
401 for (k = 1; k <= num_bands_0; k++) {
414 tmp = (sbr->
k[2] << 23) / sbr->
k[1];
416 while (tmp < 0x40000000) {
422 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
425 num_bands_1 = ((tmp + 0x400000) >> 23) * 2;
427 float invwarp = spectrum->
bs_alter_scale ? 0.76923076923076923077f
429 int num_bands_1 =
lrintf(half_bands * invwarp *
430 log2f(sbr->
k[2] / (
float)sbr->
k[1])) * 2;
436 if (vdk1_min < vdk0_max) {
439 change =
FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
441 vk1[num_bands_1] -= change;
447 for (k = 1; k <= num_bands_1; k++) {
455 sbr->
n_master = num_bands_0 + num_bands_1;
459 (num_bands_0 + 1) *
sizeof(sbr->
f_master[0]));
460 memcpy(&sbr->
f_master[num_bands_0 + 1], vk1 + 1,
461 num_bands_1 *
sizeof(sbr->
f_master[0]));
477 int i, k, last_k = -1, last_msb = -1, sb = 0;
479 int usb = sbr->
kx[1];
484 if (goal_sb < sbr->kx[1] + sbr->
m[1]) {
485 for (k = 0; sbr->
f_master[k] < goal_sb; k++) ;
491 if (k == last_k && msb == last_msb) {
497 for (i = k; i == k || sb > (sbr->
k[0] - 1 + msb - odd); i--) {
499 odd = (sb + sbr->
k[0]) & 1;
523 }
while (sb != sbr->
kx[1] + sbr->
m[1]);
541 sbr->
n[0] = (sbr->
n[1] + 1) >> 1;
544 (sbr->
n[1] + 1) *
sizeof(sbr->
f_master[0]));
549 if (sbr->
kx[1] + sbr->
m[1] > 64) {
551 "Stop frequency border too high: %d\n", sbr->
kx[1] + sbr->
m[1]);
554 if (sbr->
kx[1] > 32) {
560 temp = sbr->
n[1] & 1;
561 for (k = 1; k <= sbr->
n[0]; k++)
564 temp = (sbr->
k[2] << 23) / sbr->
kx[1];
565 while (temp < 0x40000000) {
573 sbr->
n_q = (temp + 0x400000) >> 23;
578 log2f(sbr->
k[2] / (
float)sbr->
kx[1])));
588 for (k = 1; k <= sbr->
n_q; k++) {
589 temp += (sbr->
n[0] -
temp) / (sbr->
n_q + 1 - k);
624 int abs_bord_trail = 16;
625 int num_rel_lead, num_rel_trail;
626 unsigned bs_num_env_old = ch_data->
bs_num_env;
627 int bs_frame_class, bs_num_env;
633 switch (bs_frame_class =
get_bits(gb, 2)) {
636 if (bs_num_env > 4) {
638 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
648 ch_data->
t_env[0] = 0;
651 abs_bord_trail = (abs_bord_trail + (ch_data->
bs_num_env >> 1)) /
653 for (i = 0; i < num_rel_lead; i++)
654 ch_data->
t_env[i + 1] = ch_data->
t_env[i] + abs_bord_trail;
664 ch_data->
t_env[0] = 0;
667 for (i = 0; i < num_rel_trail; i++)
682 for (i = 0; i < num_rel_lead; i++)
694 bs_num_env = num_rel_lead + num_rel_trail + 1;
696 if (bs_num_env > 5) {
698 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
706 for (i = 0; i < num_rel_lead; i++)
708 for (i = 0; i < num_rel_trail; i++)
722 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
728 if (ch_data->
t_env[i-1] >= ch_data->
t_env[i]) {
736 ch_data->
t_q[0] = ch_data->
t_env[0];
747 else if (bs_pointer == 1)
750 idx = bs_pointer - 1;
752 ch_data->
t_q[1] = ch_data->
t_env[idx];
755 ch_data->
e_a[0] = -(ch_data->
e_a[1] != bs_num_env_old);
756 ch_data->
e_a[1] = -1;
760 ch_data->
e_a[1] = bs_pointer - 1;
774 memcpy(dst->
t_q, src->
t_q,
sizeof(dst->
t_q));
779 dst->
e_a[1] = src->
e_a[1];
797 for (i = 0; i < sbr->
n_q; i++)
806 VLC_TYPE (*t_huff)[2], (*f_huff)[2];
809 const int odd = sbr->
n[1] & 1;
845 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
853 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
862 for (j = 0; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
863 k = j ? 2*j - odd : 0;
873 for (j = 1; j < sbr->
n[ch_data->
bs_freq_res[i + 1]]; j++) {
894 VLC_TYPE (*t_huff)[2], (*f_huff)[2];
912 for (j = 0; j < sbr->
n_q; j++) {
921 for (j = 1; j < sbr->
n_q; j++) {
939 int bs_extension_id,
int *num_bits_left)
941 switch (bs_extension_id) {
944 av_log(ac->
avctx,
AV_LOG_ERROR,
"Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
954 if (bs_extension_id || *num_bits_left > 16 ||
show_bits(gb, *num_bits_left))
1058 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1063 int num_bits_left =
get_bits(gb, 4);
1064 if (num_bits_left == 15)
1067 num_bits_left <<= 3;
1068 while (num_bits_left > 7) {
1072 if (num_bits_left < 0) {
1075 if (num_bits_left > 0)
1090 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1106 unsigned int num_sbr_bits = 0, num_align_bits;
1107 unsigned bytes_read;
1113 if (!sbr->sample_rate)
1114 sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1115 if (!ac->oc[1].m4ac.ext_sample_rate)
1116 ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1124 sbr->kx[0] = sbr->kx[1];
1125 sbr->m[0] = sbr->m[1];
1126 sbr->kx_and_m_pushed = 1;
1138 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1139 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1141 if (bytes_read > cnt) {
1143 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1155 #ifndef sbr_qmf_analysis
1168 memcpy(x , x+1024, (320-32)*
sizeof(x[0]));
1169 memcpy(x+288, in, 1024*
sizeof(x[0]));
1170 for (i = 0; i < 32; i++) {
1174 sbrdsp->qmf_pre_shuffle(z);
1176 for (j = 64; j < 128; j++) {
1179 "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1182 }
else if (z[j] < -(1<<24)) {
1184 "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1191 sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
1201 #ifndef sbr_qmf_synthesis
1210 INTFLOAT *
v0,
int *v_off,
const unsigned int div)
1214 const int step = 128 >> div;
1216 for (i = 0; i < 32; i++) {
1217 if (*v_off < step) {
1218 int saved_samples = (1280 - 128) >> div;
1226 for (n = 0; n < 32; n++) {
1227 X[0][i][
n] = -X[0][i][
n];
1228 X[0][i][32+
n] = X[1][i][31-
n];
1230 mdct->
imdct_half(mdct, mdct_buf[0], X[0][i]);
1231 sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1233 sbrdsp->neg_odd_64(X[1][i]);
1234 mdct->
imdct_half(mdct, mdct_buf[0], X[0][i]);
1235 mdct->
imdct_half(mdct, mdct_buf[1], X[1][i]);
1236 sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1238 dsp->
vector_fmul (out, v , sbr_qmf_window , 64 >> div);
1239 dsp->
vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div);
1240 dsp->
vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div);
1241 dsp->
vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div);
1242 dsp->
vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div);
1243 dsp->
vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div);
1244 dsp->
vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div);
1245 dsp->
vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div);
1246 dsp->
vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div);
1247 dsp->
vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div);
1259 const int t_HFGen = 8;
1261 memset(X_low, 0, 32*
sizeof(*X_low));
1262 for (k = 0; k < sbr->
kx[1]; k++) {
1263 for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1264 X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0];
1265 X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1];
1268 buf_idx = 1-buf_idx;
1269 for (k = 0; k < sbr->
kx[0]; k++) {
1270 for (i = 0; i < t_HFGen; i++) {
1271 X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
1272 X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
1297 "ERROR : no subband found for frequency %d\n", k);
1303 alpha0[p], alpha1[p], bw_array[g],
1304 2 * t_env[0], 2 * t_env[bs_num_env]);
1307 if (k < sbr->m[1] + sbr->
kx[1])
1308 memset(X_high + k, 0, (sbr->
m[1] + sbr->
kx[1] - k) *
sizeof(*X_high));
1321 memset(X, 0, 2*
sizeof(*X));
1322 for (k = 0; k < sbr->
kx[0]; k++) {
1323 for (i = 0; i < i_Temp; i++) {
1328 for (; k < sbr->
kx[0] + sbr->
m[0]; k++) {
1329 for (i = 0; i < i_Temp; i++) {
1330 X[0][i][k] = Y0[i + i_f][k][0];
1331 X[1][i][k] = Y0[i + i_f][k][1];
1335 for (k = 0; k < sbr->
kx[1]; k++) {
1336 for (i = i_Temp; i < 38; i++) {
1341 for (; k < sbr->
kx[1] + sbr->
m[1]; k++) {
1342 for (i = i_Temp; i < i_f; i++) {
1343 X[0][i][k] = Y1[i][k][0];
1344 X[1][i][k] = Y1[i][k][1];
1360 const unsigned int ilim = sbr->
n[ch_data->
bs_freq_res[e + 1]];
1364 if (sbr->
kx[1] != table[0]) {
1366 "Derived frequency tables were not regenerated.\n");
1370 for (i = 0; i < ilim; i++)
1371 for (m = table[i]; m < table[i + 1]; m++)
1376 for (i = 0; i < sbr->
n_q; i++)
1377 for (m = sbr->
f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1380 for (i = 0; i < sbr->
n[1]; i++) {
1382 const unsigned int m_midpoint =
1386 (e >= e_a[1] || (ch_data->
s_indexmapped[0][m_midpoint - sbr->
kx[1]] == 1));
1390 for (i = 0; i < ilim; i++) {
1391 int additional_sinusoid_present = 0;
1392 for (m = table[i]; m < table[i + 1]; m++) {
1394 additional_sinusoid_present = 1;
1398 memset(&sbr->
s_mapped[e][table[i] - sbr->
kx[1]], additional_sinusoid_present,
1399 (table[i + 1] - table[i]) *
sizeof(sbr->
s_mapped[e][0]));
1412 int kx1 = sbr->
kx[1];
1419 const float recip_env_size = 0.5f / (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1424 for (m = 0; m < sbr->
m[1]; m++) {
1427 e_curr[e][m] =
av_mul_sf(sum, recip_env_size);
1429 e_curr[e][m] = sum * recip_env_size;
1437 const int env_size = 2 * (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1442 for (p = 0; p < sbr->
n[ch_data->
bs_freq_res[e + 1]]; p++) {
1445 const SoftFloat den =
av_int2sf(0x20000000 / (env_size * (table[p + 1] - table[p])), 29);
1446 for (k = table[p]; k < table[p + 1]; k++) {
1452 const int den = env_size * (table[p + 1] - table[p]);
1454 for (k = table[p]; k < table[p + 1]; k++) {
1459 for (k = table[p]; k < table[p + 1]; k++) {
1460 e_curr[e][k - kx1] = sum;
1470 int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1472 int nch = (id_aac ==
TYPE_CPE) ? 2 : 1;
1475 if (id_aac != sbr->id_aac) {
1477 "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
1481 if (sbr->start && !sbr->ready_for_dequant) {
1483 "No quantized data read for sbr_dequant.\n");
1487 if (!sbr->kx_and_m_pushed) {
1488 sbr->kx[0] = sbr->kx[1];
1489 sbr->m[0] = sbr->m[1];
1491 sbr->kx_and_m_pushed = 0;
1496 sbr->ready_for_dequant = 0;
1498 for (ch = 0; ch < nch; ch++) {
1500 sbr_qmf_analysis(ac->fdsp, &sbr->mdct_ana, &sbr->dsp, ch ?
R : L, sbr->data[ch].analysis_filterbank_samples,
1501 (
INTFLOAT*)sbr->qmf_filter_scratch,
1502 sbr->data[ch].W, sbr->data[ch].Ypos);
1503 sbr->c.sbr_lf_gen(ac, sbr, sbr->X_low,
1504 (
const INTFLOAT (*)[32][32][2]) sbr->data[ch].W,
1505 sbr->data[ch].Ypos);
1506 sbr->data[
ch].Ypos ^= 1;
1508 sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
1509 (
const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]);
1513 (
const INTFLOAT (*)[40][2]) sbr->X_low,
1514 (
const INTFLOAT (*)[2]) sbr->alpha0,
1515 (
const INTFLOAT (*)[2]) sbr->alpha1,
1516 sbr->data[ch].bw_array, sbr->data[ch].t_env,
1517 sbr->data[ch].bs_num_env);
1520 err =
sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1524 sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
1525 (
const INTFLOAT (*)[40][2]) sbr->X_high,
1526 sbr, &sbr->data[ch],
1532 sbr->c.sbr_x_gen(sbr, sbr->X[ch],
1533 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos],
1534 (
const INTFLOAT (*)[64][2]) sbr->data[ch].Y[ sbr->data[ch].Ypos],
1535 (
const INTFLOAT (*)[40][2]) sbr->X_low, ch);
1538 if (ac->oc[1].m4ac.ps == 1) {
1539 if (sbr->ps.start) {
1542 memcpy(sbr->X[1], sbr->X[0],
sizeof(sbr->X[0]));
1548 L, sbr->X[0], sbr->qmf_filter_scratch,
1549 sbr->data[0].synthesis_filterbank_samples,
1550 &sbr->data[0].synthesis_filterbank_samples_offset,
1554 R, sbr->X[1], sbr->qmf_filter_scratch,
1555 sbr->data[1].synthesis_filterbank_samples,
1556 &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 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)
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.
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)
#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]
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
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 ff_aacsbr_func_ptr_init_mips(AACSBRContext *c)
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)
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)
static int read_sbr_envelope(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
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.
#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.
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)
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.
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
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
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 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 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]
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)
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
static INTFLOAT sbr_qmf_window_ds[320]
< window coefficients for analysis/synthesis QMF banks
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_YASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
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
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)
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]
#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)