Go to the documentation of this file.
85 sbr->
kx[0] = sbr->
kx[1];
124 return *(
const int16_t *)
a - *(
const int16_t *)
b;
130 for (
i = 0;
i <= last_el;
i++)
141 static const INTFLOAT bands_warped[3] = {
Q23(1.32715174233856803909
f),
142 Q23(1.18509277094158210129
f),
143 Q23(1.11987160404675912501
f) };
145 int16_t patch_borders[7];
148 patch_borders[0] = sbr->
kx[1];
155 memcpy(sbr->
f_tablelim + sbr->
n[0] + 1, patch_borders + 1,
156 (sbr->
num_patches - 1) *
sizeof(patch_borders[0]));
163 while (out < sbr->f_tablelim + sbr->
n_lim) {
165 if ((*in << 23) >= *
out * lim_bands_per_octave_warped) {
167 if (*in >= *
out * lim_bands_per_octave_warped) {
170 }
else if (*in == *
out ||
192 uint8_t bs_header_extra_1;
193 uint8_t bs_header_extra_2;
217 if (bs_header_extra_1) {
231 if (bs_header_extra_2) {
252 for (
i = 1;
i < nel;
i++)
264 if (bs_xover_band >= n_master) {
266 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
277 unsigned int temp, max_qmf_subbands = 0;
278 unsigned int start_min, stop_min;
280 const int8_t *sbr_offset_ptr;
296 case 44100:
case 48000:
case 64000:
299 case 88200:
case 96000:
case 128000:
case 176400:
case 192000:
304 "Unsupported sample rate for SBR: %d\n", sbr->
sample_rate);
321 sbr->
k[2] = stop_min;
325 sbr->
k[2] += stop_dk[k];
327 sbr->
k[2] = 2*sbr->
k[0];
329 sbr->
k[2] = 3*sbr->
k[0];
335 sbr->
k[2] =
FFMIN(64, sbr->
k[2]);
339 max_qmf_subbands = 48;
341 max_qmf_subbands = 35;
343 max_qmf_subbands = 32;
347 if (sbr->
k[2] - sbr->
k[0] > max_qmf_subbands) {
349 "Invalid bitstream, too many QMF subbands: %d\n", sbr->
k[2] - sbr->
k[0]);
357 sbr->
n_master = ((sbr->
k[2] - sbr->
k[0] + (dk&2)) >> dk) << 1;
361 for (k = 1; k <= sbr->
n_master; k++)
364 k2diff = sbr->
k[2] - sbr->
k[0] - sbr->
n_master * dk;
373 for (k = 1; k <= sbr->
n_master; k++)
378 int two_regions, num_bands_0;
379 int vdk0_max, vdk1_min;
385 if (49 * sbr->
k[2] > 110 * sbr->
k[0]) {
387 sbr->
k[1] = 2 * sbr->
k[0];
390 sbr->
k[1] = sbr->
k[2];
394 tmp = (sbr->
k[1] << 23) / sbr->
k[0];
395 while (
tmp < 0x40000000) {
401 tmp = (((
tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
402 num_bands_0 = ((
tmp + 0x400000) >> 23) * 2;
404 num_bands_0 =
lrintf(half_bands *
log2f(sbr->
k[1] / (
float)sbr->
k[0])) * 2;
407 if (num_bands_0 <= 0) {
417 vdk0_max = vk0[num_bands_0];
420 for (k = 1; k <= num_bands_0; k++) {
433 tmp = (sbr->
k[2] << 23) / sbr->
k[1];
435 while (
tmp < 0x40000000) {
441 tmp = (((
tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
444 num_bands_1 = ((
tmp + 0x400000) >> 23) * 2;
446 float invwarp = spectrum->
bs_alter_scale ? 0.76923076923076923077f
448 int num_bands_1 =
lrintf(half_bands * invwarp *
449 log2f(sbr->
k[2] / (
float)sbr->
k[1])) * 2;
455 if (vdk1_min < vdk0_max) {
458 change =
FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
460 vk1[num_bands_1] -= change;
466 for (k = 1; k <= num_bands_1; k++) {
474 sbr->
n_master = num_bands_0 + num_bands_1;
478 (num_bands_0 + 1) *
sizeof(sbr->
f_master[0]));
479 memcpy(&sbr->
f_master[num_bands_0 + 1], vk1 + 1,
480 num_bands_1 *
sizeof(sbr->
f_master[0]));
496 int i, k, last_k = -1, last_msb = -1, sb = 0;
498 int usb = sbr->
kx[1];
503 if (goal_sb < sbr->kx[1] + sbr->
m[1]) {
504 for (k = 0; sbr->
f_master[k] < goal_sb; k++) ;
510 if (k == last_k && msb == last_msb) {
516 for (
i = k;
i == k || sb > (sbr->
k[0] - 1 + msb - odd);
i--) {
518 odd = (sb + sbr->
k[0]) & 1;
542 }
while (sb != sbr->
kx[1] + sbr->
m[1]);
560 sbr->
n[0] = (sbr->
n[1] + 1) >> 1;
563 (sbr->
n[1] + 1) *
sizeof(sbr->
f_master[0]));
568 if (sbr->
kx[1] + sbr->
m[1] > 64) {
570 "Stop frequency border too high: %d\n", sbr->
kx[1] + sbr->
m[1]);
573 if (sbr->
kx[1] > 32) {
579 temp = sbr->
n[1] & 1;
580 for (k = 1; k <= sbr->
n[0]; k++)
583 temp = (sbr->
k[2] << 23) / sbr->
kx[1];
584 while (
temp < 0x40000000) {
592 sbr->
n_q = (
temp + 0x400000) >> 23;
597 log2f(sbr->
k[2] / (
float)sbr->
kx[1])));
608 for (k = 1; k <= sbr->
n_q; k++) {
644 int abs_bord_trail = 16;
645 int num_rel_lead, num_rel_trail;
646 unsigned bs_num_env_old = ch_data->
bs_num_env;
647 int bs_frame_class, bs_num_env;
653 switch (bs_frame_class =
get_bits(gb, 2)) {
656 if (bs_num_env > (sbr->
usac ? 8 : 5)) {
658 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
668 ch_data->
t_env[0] = 0;
671 abs_bord_trail = (abs_bord_trail + (ch_data->
bs_num_env >> 1)) /
673 for (
i = 0;
i < num_rel_lead;
i++)
674 ch_data->
t_env[
i + 1] = ch_data->
t_env[
i] + abs_bord_trail;
684 ch_data->
t_env[0] = 0;
687 for (
i = 0;
i < num_rel_trail;
i++)
702 for (
i = 0;
i < num_rel_lead;
i++)
714 bs_num_env = num_rel_lead + num_rel_trail + 1;
716 if (bs_num_env > 5) {
718 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
726 for (
i = 0;
i < num_rel_lead;
i++)
728 for (
i = 0;
i < num_rel_trail;
i++)
742 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
756 ch_data->
t_q[0] = ch_data->
t_env[0];
767 else if (bs_pointer == 1)
770 idx = bs_pointer - 1;
772 ch_data->
t_q[1] = ch_data->
t_env[idx];
775 ch_data->
e_a[0] = -(ch_data->
e_a[1] != bs_num_env_old);
776 ch_data->
e_a[1] = -1;
780 ch_data->
e_a[1] = bs_pointer - 1;
787 dst->bs_freq_res[0] =
dst->bs_freq_res[
dst->bs_num_env];
788 dst->t_env_num_env_old =
dst->t_env[
dst->bs_num_env];
789 dst->e_a[0] = -(
dst->e_a[1] !=
dst->bs_num_env);
792 memcpy(
dst->bs_freq_res+1,
src->bs_freq_res+1,
sizeof(
dst->bs_freq_res)-
sizeof(*
dst->bs_freq_res));
793 memcpy(
dst->t_env,
src->t_env,
sizeof(
dst->t_env));
794 memcpy(
dst->t_q,
src->t_q,
sizeof(
dst->t_q));
795 dst->bs_num_env =
src->bs_num_env;
796 dst->bs_amp_res =
src->bs_amp_res;
797 dst->bs_num_noise =
src->bs_num_noise;
798 dst->bs_frame_class =
src->bs_frame_class;
799 dst->e_a[1] =
src->e_a[1];
804 SBRData *ch_data,
int indep_flag)
833 for (
i = 0;
i < sbr->
n_q;
i++)
842 const VLCElem *t_huff, *f_huff;
844 const int odd = sbr->
n[1] & 1;
890 k = j ? 2*j - odd : 0;
928 const VLCElem *t_huff, *f_huff;
941 for (j = 0; j < sbr->
n_q; j++) {
950 for (j = 1; j < sbr->
n_q; j++) {
968 int bs_extension_id,
int *num_bits_left)
970 switch (bs_extension_id) {
973 av_log(ac->
avctx,
AV_LOG_ERROR,
"Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
985 if (bs_extension_id || *num_bits_left > 16 ||
show_bits(gb, *num_bits_left))
1089 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1094 int num_bits_left =
get_bits(gb, 4);
1095 if (num_bits_left == 15)
1098 num_bits_left <<= 3;
1099 while (num_bits_left > 7) {
1103 if (num_bits_left < 0) {
1106 if (num_bits_left > 0)
1121 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1136 int cnt,
int id_aac)
1139 unsigned int num_sbr_bits = 0, num_align_bits;
1140 unsigned bytes_read;
1147 sbr->
sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1148 if (!ac->oc[1].m4ac.ext_sample_rate)
1149 ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1157 sbr->
kx[0] = sbr->
kx[1];
1158 sbr->
m[0] = sbr->
m[1];
1171 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1172 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1174 if (bytes_read > cnt) {
1176 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1211 int sbr_ch,
int indep_flag)
1215 int info_present = 1;
1216 int header_present = 1;
1240 if (header_present) {
1263 sbr->
kx[0] = sbr->
kx[1];
1264 sbr->
m[0] = sbr->
m[1];
1358 #ifndef sbr_qmf_analysis
1373 memcpy(x , x+1024, (320-32)*
sizeof(x[0]));
1374 memcpy(x+288, in, 1024*
sizeof(x[0]));
1375 for (
i = 0;
i < 32;
i++) {
1379 sbrdsp->qmf_pre_shuffle(z);
1381 for (j = 64; j < 128; j++) {
1384 "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1387 }
else if (z[j] < -(1<<24)) {
1389 "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1395 mdct_fn(mdct, z, z + 64,
sizeof(
INTFLOAT));
1396 sbrdsp->qmf_post_shuffle(
W[buf_idx][
i], z);
1406 #ifndef sbr_qmf_synthesis
1415 INTFLOAT *v0,
int *v_off,
const unsigned int div)
1419 const int step = 128 >> div;
1421 for (
i = 0;
i < 32;
i++) {
1422 if (*v_off <
step) {
1423 int saved_samples = (1280 - 128) >> div;
1431 for (n = 0; n < 32; n++) {
1432 X[0][
i][ n] = -
X[0][
i][n];
1433 X[0][
i][32+n] =
X[1][
i][31-n];
1435 mdct_fn(mdct, mdct_buf[0],
X[0][
i],
sizeof(
INTFLOAT));
1436 sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1438 sbrdsp->neg_odd_64(
X[1][
i]);
1439 mdct_fn(mdct, mdct_buf[0],
X[0][
i],
sizeof(
INTFLOAT));
1440 mdct_fn(mdct, mdct_buf[1],
X[1][
i],
sizeof(
INTFLOAT));
1441 sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1464 const int t_HFGen = 8;
1466 memset(X_low, 0, 32*
sizeof(*X_low));
1467 for (k = 0; k < sbr->
kx[1]; k++) {
1468 for (
i = t_HFGen;
i < i_f + t_HFGen;
i++) {
1469 X_low[k][
i][0] =
W[buf_idx][
i - t_HFGen][k][0];
1470 X_low[k][
i][1] =
W[buf_idx][
i - t_HFGen][k][1];
1473 buf_idx = 1-buf_idx;
1474 for (k = 0; k < sbr->
kx[0]; k++) {
1475 for (
i = 0;
i < t_HFGen;
i++) {
1476 X_low[k][
i][0] =
W[buf_idx][
i + i_f - t_HFGen][k][0];
1477 X_low[k][
i][1] =
W[buf_idx][
i + i_f - t_HFGen][k][1];
1487 const INTFLOAT bw_array[5],
const uint8_t *t_env,
1502 "ERROR : no subband found for frequency %d\n", k);
1508 alpha0[p], alpha1[p], bw_array[
g],
1509 2 * t_env[0], 2 * t_env[bs_num_env]);
1512 if (k < sbr->m[1] + sbr->
kx[1])
1513 memset(X_high + k, 0, (sbr->
m[1] + sbr->
kx[1] - k) *
sizeof(*X_high));
1521 const INTFLOAT X_low[32][40][2],
int ch)
1526 memset(
X, 0, 2*
sizeof(*
X));
1527 for (k = 0; k < sbr->
kx[0]; k++) {
1528 for (
i = 0;
i < i_Temp;
i++) {
1533 for (; k < sbr->
kx[0] + sbr->
m[0]; k++) {
1534 for (
i = 0;
i < i_Temp;
i++) {
1535 X[0][
i][k] = Y0[
i + i_f][k][0];
1536 X[1][
i][k] = Y0[
i + i_f][k][1];
1540 for (k = 0; k < sbr->
kx[1]; k++) {
1541 for (
i = i_Temp;
i < 38;
i++) {
1546 for (; k < sbr->
kx[1] + sbr->
m[1]; k++) {
1547 for (
i = i_Temp;
i < i_f;
i++) {
1548 X[0][
i][k] = Y1[
i][k][0];
1549 X[1][
i][k] = Y1[
i][k][1];
1565 const unsigned int ilim = sbr->
n[ch_data->
bs_freq_res[e + 1]];
1571 "Derived frequency tables were not regenerated.\n");
1575 for (
i = 0;
i < ilim;
i++)
1581 for (
i = 0;
i < sbr->
n_q;
i++)
1582 for (m = sbr->
f_tablenoise[
i]; m < sbr->f_tablenoise[
i + 1]; m++)
1585 for (
i = 0;
i < sbr->
n[1];
i++) {
1587 const unsigned int m_midpoint =
1591 (e >= e_a[1] || (ch_data->
s_indexmapped[0][m_midpoint - sbr->
kx[1]] == 1));
1595 for (
i = 0;
i < ilim;
i++) {
1596 int additional_sinusoid_present = 0;
1599 additional_sinusoid_present = 1;
1603 memset(&sbr->
s_mapped[e][
table[
i] - sbr->
kx[1]], additional_sinusoid_present,
1617 int kx1 = sbr->
kx[1];
1624 const float recip_env_size = 0.5f / (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1629 for (m = 0; m < sbr->
m[1]; m++) {
1632 e_curr[e][m] =
av_mul_sf(sum, recip_env_size);
1634 e_curr[e][m] = sum * recip_env_size;
1642 const int env_size = 2 * (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1647 for (p = 0; p < sbr->
n[ch_data->
bs_freq_res[e + 1]]; p++) {
1657 const int den = env_size * (
table[p + 1] -
table[p]);
1665 e_curr[e][k - kx1] = sum;
1673 int id_aac,
void *L_,
void *R_)
1677 int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->
sample_rate;
1679 int nch = (id_aac ==
TYPE_CPE) ? 2 : 1;
1682 if (id_aac != sbr->
id_aac) {
1684 "element type mismatch %d != %d\n", id_aac, sbr->
id_aac);
1690 "No quantized data read for sbr_dequant.\n");
1695 sbr->
kx[0] = sbr->
kx[1];
1696 sbr->
m[0] = sbr->
m[1];
1705 for (ch = 0; ch < nch; ch++) {
1734 sbr, &sbr->
data[ch],
1746 if (ac->oc[1].m4ac.ps == 1) {
1750 memcpy(sbr->
X[1], sbr->
X[0],
sizeof(sbr->
X[0]));
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)
int ff_aac_sbr_decode_usac_data(AACDecContext *ac, ChannelElement *che, AACUsacElemConfig *ue, GetBitContext *gb, int sbr_ch, int indep_flag)
Decode frame SBR data, USAC.
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int sbr_hf_gen(AACDecContext *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)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
av_cold void AAC_RENAME() ff_aac_sbr_init(void)
Initialize SBR.
unsigned bs_limiter_gains
static const ElemCat * elements[ELEMENT_COUNT]
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
INTFLOAT X[2][2][38][64]
QMF values of the reconstructed signal.
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
static int get_bits_count(const GetBitContext *s)
int AAC_RENAME() ff_ps_apply(PSContext *ps, INTFLOAT L[2][38][64], INTFLOAT R[2][38][64], int top)
static const INTFLOAT sbr_qmf_window_ds[320]
static void sbr_hf_inverse_filter(SBRDSPContext *dsp, float(*alpha0)[2], float(*alpha1)[2], const float X_low[32][40][2], int k0)
High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering (14496-3 sp04 p214) Warning: Thi...
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
int ff_ps_read_data(void *logctx, GetBitContext *gb, PSCommonContext *ps, int bits_left)
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
static int read_sbr_noise(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
static const uint16_t table[]
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
uint8_t env_facs_q[9][48]
Envelope scalefactors.
static void copy_sbr_grid(SBRData *dst, const SBRData *src)
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])
#define AV_LOG_VERBOSE
Detailed information.
av_cold void AAC_RENAME() ff_ps_init(void)
INTFLOAT X_low[32][40][2]
QMF low frequency input to the HF generator.
uint8_t temp_shape_mode[6]
static int qsort_comparison_function_int16(const void *a, const void *b)
SingleChannelElement ch[2]
static void copy_usac_default_header(SpectralBandReplication *sbr, AACUsacElemConfig *ue)
uint8_t s_mapped[8][48]
Sinusoidal presence, remapped.
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
static void sbr_qmf_analysis(AVFloatDSPContext *dsp, AVTXContext *mdct, av_tx_fn mdct_fn, 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 void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int indep_flag)
Read how the envelope and noise floor data is delta coded.
static void sbr_gain_calc(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 ...
const VLCElem * ff_aac_sbr_vlc[10]
static void skip_bits(GetBitContext *s, int n)
int e_a[2]
l_APrev and l_A
INTFLOAT analysis_filterbank_samples[1312]
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
uint8_t t_env[9]
Envelope time borders.
unsigned bs_interpol_freq
static int sbr_make_f_master(AACDecContext *ac, SpectralBandReplication *sbr, SpectrumParameters *spectrum)
Master Frequency Band Table (14496-3 sp04 p194)
SpectralBandReplication sbr
AAC_SIGNE n_master
The number of frequency bands in f_master.
unsigned bs_add_harmonic_flag
#define ue(name, range_min, range_max)
static int sbr_lf_gen(SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx)
Generate the subband filtered lowband.
AAC_FLOAT noise_facs[3][5]
static void sbr_hf_assemble(float Y1[38][64][2], const float X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Assembling HF Signals (14496-3 sp04 p220)
static int read_sbr_single_channel_element(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
PredictorState predictor_state[2][MAX_PREDICTORS]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
INTFLOAT qmf_filter_scratch[5][64]
static int read_sbr_grid(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
AAC_FLOAT env_facs[9][48]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static void read_sbr_extension(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int bs_extension_id, int *num_bits_left)
static const int8_t sbr_offset[6][16]
window coefficients for analysis/synthesis QMF banks
uint16_t f_tablenoise[6]
Frequency borders for noise floors.
void AAC_RENAME() ff_aac_sbr_apply(AACDecContext *ac, ChannelElement *che, int id_aac, void *L_, void *R_)
Apply one SBR element to one AAC element.
AAC_FLOAT e_origmapped[8][48]
Dequantized envelope scalefactors, remapped.
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)
AAC_SIGNE n_lim
Number of limiter bands.
int Ypos
QMF output of the HF adjustor.
uint16_t f_tablelow[25]
Frequency borders for low resolution SBR.
static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb, int is_usac)
static const SoftFloat FLOAT_0
0.0
static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
uint16_t f_tablelim[30]
Frequency borders for the limiter.
uint8_t bs_add_harmonic[48]
static unsigned int get_bits1(GetBitContext *s)
aacsbr functions pointers
static int fixed_log(int x)
#define SBR_SYNTHESIS_BUF_SIZE
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
unsigned bs_smoothing_mode
static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64], const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2], const INTFLOAT X_low[32][40][2], int ch)
Generate the subband filtered lowband.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Spectral Band Replication header - spectrum parameters that invoke a reset if they differ from the pr...
static void sbr_qmf_synthesis(AVTXContext *mdct, av_tx_fn mdct_fn, 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)
uint16_t f_master[49]
The master QMF frequency grouping.
static int sbr_mapping(AACDecContext *ac, SpectralBandReplication *sbr, SBRData *ch_data, int e_a[2])
High Frequency Adjustment (14496-3 sp04 p217) and Mapping (14496-3 sp04 p217)
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.
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
static void sbr_turnoff(SpectralBandReplication *sbr)
Places SBR in pure upsampling mode.
Spectral Band Replication.
INTFLOAT alpha0[64][2]
Zeroth coefficient used to filter the subband signals.
uint8_t bs_invf_mode[2][5]
static int read_sbr_envelope(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
INTFLOAT alpha1[64][2]
First coefficient used to filter the subband signals.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
AAC_SIGNE n_q
Number of noise floor bands.
uint8_t patch_start_subband[6]
static const int CONST_076923
int ff_aac_sbr_config_usac(AACDecContext *ac, ChannelElement *che, AACUsacElemConfig *ue)
Due to channel allocation not being known upon SBR parameter transmission, supply the parameters sepa...
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
void(* sbr_hf_inverse_filter)(SBRDSPContext *dsp, INTFLOAT(*alpha0)[2], INTFLOAT(*alpha1)[2], const INTFLOAT X_low[32][40][2], int k0)
void AAC_RENAME() ff_sbrdsp_init(SBRDSPContext *s)
static void aacsbr_func_ptr_init(AACSBRContext *c)
@ F_HUFFMAN_ENV_BAL_1_5DB
static const int CONST_RECIP_LN2
AAC_FLOAT q_mapped[8][48]
Dequantized noise scalefactors, remapped.
#define i(width, name, range_min, range_max)
static const int8_t ceil_log2[]
ceil(log2(index+1))
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Spectral Band Replication per channel data.
channel element - generic struct for SCE/CPE/CCE/LFE
INTFLOAT bw_array[5]
Chirp factors.
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...
INTFLOAT X_high[64][40][2]
QMF output of the HF generator.
static int in_table_int16(const int16_t *table, int last_el, int16_t needle)
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
Limiter Frequency Band Table (14496-3 sp04 p198)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
OutputConfiguration oc[2]
static int sbr_make_f_derived(AACDecContext *ac, SpectralBandReplication *sbr)
Derived Frequency Band Tables (14496-3 sp04 p197)
INTFLOAT W[2][32][32][2]
QMF values of the original signal.
static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read inverse filtering data.
static int array[MAX_W *MAX_W]
@ T_HUFFMAN_NOISE_BAL_3_0DB
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
@ T_HUFFMAN_ENV_BAL_1_5DB
static int array_min_int16(const int16_t *array, int nel)
@ F_HUFFMAN_ENV_BAL_3_0DB
main AAC decoding context
static int sbr_hf_calc_npatches(AACDecContext *ac, SpectralBandReplication *sbr)
High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
main external API structure.
av_cold int AAC_RENAME() ff_aac_sbr_ctx_alloc_init(AACDecContext *ac, ChannelElement **che, int id_aac)
Allocate an ExtChannelElement (if necessary) and initialize the SBR context contained in it.
#define AV_PROFILE_AAC_HE_V2
struct AVCodecContext * avctx
int ps
-1 implicit, 1 presence
static void sbr_env_estimate(AAC_FLOAT(*e_curr)[48], INTFLOAT X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data)
Estimation of current envelope (14496-3 sp04 p218)
uint8_t t_q[3]
Noise time borders.
SpectrumParameters spectrum_params
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
static const INTFLOAT sbr_qmf_window_us[640]
uint16_t f_tablehigh[49]
Frequency borders for high resolution SBR.
uint8_t noise_facs_q[3][5]
Noise scalefactors.
INTFLOAT synthesis_filterbank_samples[SBR_SYNTHESIS_BUF_SIZE]
static void sbr_reset(AACDecContext *ac, SpectralBandReplication *sbr)
unsigned bs_limiter_bands
uint8_t patch_num_subbands[6]
int AAC_RENAME() ff_aac_sbr_decode_extension(AACDecContext *ac, ChannelElement *che, GetBitContext *gb_host, int crc, int cnt, int id_aac)
Decode Spectral Band Replication extension data; reference: table 4.55.
#define avpriv_request_sample(...)
AAC_FLOAT(* sum_square)(INTFLOAT(*x)[2], int n)
static void AAC_RENAME() ff_ps_ctx_init(PSContext *ps)
static SpectralBandReplication * get_sbr(ChannelElement *ch)
#define ENVELOPE_ADJUSTMENT_OFFSET
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static int read_sbr_channel_pair_element(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static unsigned int read_sbr_data(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int id_aac)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
@ T_HUFFMAN_ENV_BAL_3_0DB
int(* sbr_lf_gen)(SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx)
static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec, int elements)
av_cold void AAC_RENAME() ff_aac_sbr_ctx_close(ChannelElement *che)
Close the SBR context implicitly contained in a ChannelElement.
int synthesis_filterbank_samples_offset
uint8_t s_indexmapped[9][48]
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
AAC_FLOAT e_curr[8][48]
Estimated envelope.