Go to the documentation of this file.
84 sbr->
kx[0] = sbr->
kx[1];
123 return *(
const int16_t *)
a - *(
const int16_t *)
b;
129 for (
i = 0;
i <= last_el;
i++)
140 static const INTFLOAT bands_warped[3] = {
Q23(1.32715174233856803909
f),
141 Q23(1.18509277094158210129
f),
142 Q23(1.11987160404675912501
f) };
144 int16_t patch_borders[7];
147 patch_borders[0] = sbr->
kx[1];
154 memcpy(sbr->
f_tablelim + sbr->
n[0] + 1, patch_borders + 1,
155 (sbr->
num_patches - 1) *
sizeof(patch_borders[0]));
162 while (out < sbr->f_tablelim + sbr->
n_lim) {
164 if ((*in << 23) >= *
out * lim_bands_per_octave_warped) {
166 if (*in >= *
out * lim_bands_per_octave_warped) {
169 }
else if (*in == *
out ||
190 uint8_t bs_header_extra_1;
191 uint8_t bs_header_extra_2;
210 if (bs_header_extra_1) {
224 if (bs_header_extra_2) {
245 for (
i = 1;
i < nel;
i++)
257 if (bs_xover_band >= n_master) {
259 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
270 unsigned int temp, max_qmf_subbands = 0;
271 unsigned int start_min, stop_min;
273 const int8_t *sbr_offset_ptr;
289 case 44100:
case 48000:
case 64000:
292 case 88200:
case 96000:
case 128000:
case 176400:
case 192000:
297 "Unsupported sample rate for SBR: %d\n", sbr->
sample_rate);
314 sbr->
k[2] = stop_min;
318 sbr->
k[2] += stop_dk[k];
320 sbr->
k[2] = 2*sbr->
k[0];
322 sbr->
k[2] = 3*sbr->
k[0];
328 sbr->
k[2] =
FFMIN(64, sbr->
k[2]);
332 max_qmf_subbands = 48;
334 max_qmf_subbands = 35;
336 max_qmf_subbands = 32;
340 if (sbr->
k[2] - sbr->
k[0] > max_qmf_subbands) {
342 "Invalid bitstream, too many QMF subbands: %d\n", sbr->
k[2] - sbr->
k[0]);
350 sbr->
n_master = ((sbr->
k[2] - sbr->
k[0] + (dk&2)) >> dk) << 1;
354 for (k = 1; k <= sbr->
n_master; k++)
357 k2diff = sbr->
k[2] - sbr->
k[0] - sbr->
n_master * dk;
366 for (k = 1; k <= sbr->
n_master; k++)
371 int two_regions, num_bands_0;
372 int vdk0_max, vdk1_min;
378 if (49 * sbr->
k[2] > 110 * sbr->
k[0]) {
380 sbr->
k[1] = 2 * sbr->
k[0];
383 sbr->
k[1] = sbr->
k[2];
387 tmp = (sbr->
k[1] << 23) / sbr->
k[0];
388 while (
tmp < 0x40000000) {
394 tmp = (((
tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
395 num_bands_0 = ((
tmp + 0x400000) >> 23) * 2;
397 num_bands_0 =
lrintf(half_bands *
log2f(sbr->
k[1] / (
float)sbr->
k[0])) * 2;
400 if (num_bands_0 <= 0) {
410 vdk0_max = vk0[num_bands_0];
413 for (k = 1; k <= num_bands_0; k++) {
426 tmp = (sbr->
k[2] << 23) / sbr->
k[1];
428 while (
tmp < 0x40000000) {
434 tmp = (((
tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
437 num_bands_1 = ((
tmp + 0x400000) >> 23) * 2;
439 float invwarp = spectrum->
bs_alter_scale ? 0.76923076923076923077f
441 int num_bands_1 =
lrintf(half_bands * invwarp *
442 log2f(sbr->
k[2] / (
float)sbr->
k[1])) * 2;
448 if (vdk1_min < vdk0_max) {
451 change =
FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
453 vk1[num_bands_1] -= change;
459 for (k = 1; k <= num_bands_1; k++) {
467 sbr->
n_master = num_bands_0 + num_bands_1;
471 (num_bands_0 + 1) *
sizeof(sbr->
f_master[0]));
472 memcpy(&sbr->
f_master[num_bands_0 + 1], vk1 + 1,
473 num_bands_1 *
sizeof(sbr->
f_master[0]));
489 int i, k, last_k = -1, last_msb = -1, sb = 0;
491 int usb = sbr->
kx[1];
496 if (goal_sb < sbr->kx[1] + sbr->
m[1]) {
497 for (k = 0; sbr->
f_master[k] < goal_sb; k++) ;
503 if (k == last_k && msb == last_msb) {
509 for (
i = k;
i == k || sb > (sbr->
k[0] - 1 + msb - odd);
i--) {
511 odd = (sb + sbr->
k[0]) & 1;
535 }
while (sb != sbr->
kx[1] + sbr->
m[1]);
553 sbr->
n[0] = (sbr->
n[1] + 1) >> 1;
556 (sbr->
n[1] + 1) *
sizeof(sbr->
f_master[0]));
561 if (sbr->
kx[1] + sbr->
m[1] > 64) {
563 "Stop frequency border too high: %d\n", sbr->
kx[1] + sbr->
m[1]);
566 if (sbr->
kx[1] > 32) {
572 temp = sbr->
n[1] & 1;
573 for (k = 1; k <= sbr->
n[0]; k++)
576 temp = (sbr->
k[2] << 23) / sbr->
kx[1];
577 while (
temp < 0x40000000) {
585 sbr->
n_q = (
temp + 0x400000) >> 23;
590 log2f(sbr->
k[2] / (
float)sbr->
kx[1])));
600 for (k = 1; k <= sbr->
n_q; k++) {
636 int abs_bord_trail = 16;
637 int num_rel_lead, num_rel_trail;
638 unsigned bs_num_env_old = ch_data->
bs_num_env;
639 int bs_frame_class, bs_num_env;
645 switch (bs_frame_class =
get_bits(gb, 2)) {
648 if (bs_num_env > 4) {
650 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
660 ch_data->
t_env[0] = 0;
663 abs_bord_trail = (abs_bord_trail + (ch_data->
bs_num_env >> 1)) /
665 for (
i = 0;
i < num_rel_lead;
i++)
666 ch_data->
t_env[
i + 1] = ch_data->
t_env[
i] + abs_bord_trail;
676 ch_data->
t_env[0] = 0;
679 for (
i = 0;
i < num_rel_trail;
i++)
694 for (
i = 0;
i < num_rel_lead;
i++)
706 bs_num_env = num_rel_lead + num_rel_trail + 1;
708 if (bs_num_env > 5) {
710 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
718 for (
i = 0;
i < num_rel_lead;
i++)
720 for (
i = 0;
i < num_rel_trail;
i++)
734 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
748 ch_data->
t_q[0] = ch_data->
t_env[0];
759 else if (bs_pointer == 1)
762 idx = bs_pointer - 1;
764 ch_data->
t_q[1] = ch_data->
t_env[idx];
767 ch_data->
e_a[0] = -(ch_data->
e_a[1] != bs_num_env_old);
768 ch_data->
e_a[1] = -1;
772 ch_data->
e_a[1] = bs_pointer - 1;
786 memcpy(dst->
t_q,
src->t_q,
sizeof(dst->
t_q));
791 dst->
e_a[1] =
src->e_a[1];
809 for (
i = 0;
i < sbr->
n_q;
i++)
818 const VLCElem *t_huff, *f_huff;
820 const int odd = sbr->
n[1] & 1;
866 k = j ? 2*j - odd : 0;
897 const VLCElem *t_huff, *f_huff;
910 for (j = 0; j < sbr->
n_q; j++) {
919 for (j = 1; j < sbr->
n_q; j++) {
937 int bs_extension_id,
int *num_bits_left)
939 switch (bs_extension_id) {
942 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");
1105 int cnt,
int id_aac)
1108 unsigned int num_sbr_bits = 0, num_align_bits;
1109 unsigned bytes_read;
1116 sbr->
sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1117 if (!ac->oc[1].m4ac.ext_sample_rate)
1118 ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1126 sbr->
kx[0] = sbr->
kx[1];
1127 sbr->
m[0] = sbr->
m[1];
1140 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1141 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1143 if (bytes_read > cnt) {
1145 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1157 #ifndef sbr_qmf_analysis
1172 memcpy(x , x+1024, (320-32)*
sizeof(x[0]));
1173 memcpy(x+288, in, 1024*
sizeof(x[0]));
1174 for (
i = 0;
i < 32;
i++) {
1178 sbrdsp->qmf_pre_shuffle(z);
1180 for (j = 64; j < 128; j++) {
1183 "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1186 }
else if (z[j] < -(1<<24)) {
1188 "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1194 mdct_fn(mdct, z, z + 64,
sizeof(
INTFLOAT));
1195 sbrdsp->qmf_post_shuffle(
W[buf_idx][
i], z);
1205 #ifndef sbr_qmf_synthesis
1214 INTFLOAT *
v0,
int *v_off,
const unsigned int div)
1218 const int step = 128 >> div;
1220 for (
i = 0;
i < 32;
i++) {
1221 if (*v_off <
step) {
1222 int saved_samples = (1280 - 128) >> div;
1230 for (n = 0; n < 32; n++) {
1231 X[0][
i][ n] = -
X[0][
i][n];
1232 X[0][
i][32+n] =
X[1][
i][31-n];
1234 mdct_fn(mdct, mdct_buf[0],
X[0][
i],
sizeof(
INTFLOAT));
1235 sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1237 sbrdsp->neg_odd_64(
X[1][
i]);
1238 mdct_fn(mdct, mdct_buf[0],
X[0][
i],
sizeof(
INTFLOAT));
1239 mdct_fn(mdct, mdct_buf[1],
X[1][
i],
sizeof(
INTFLOAT));
1240 sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1263 const int t_HFGen = 8;
1265 memset(X_low, 0, 32*
sizeof(*X_low));
1266 for (k = 0; k < sbr->
kx[1]; k++) {
1267 for (
i = t_HFGen;
i < i_f + t_HFGen;
i++) {
1268 X_low[k][
i][0] =
W[buf_idx][
i - t_HFGen][k][0];
1269 X_low[k][
i][1] =
W[buf_idx][
i - t_HFGen][k][1];
1272 buf_idx = 1-buf_idx;
1273 for (k = 0; k < sbr->
kx[0]; k++) {
1274 for (
i = 0;
i < t_HFGen;
i++) {
1275 X_low[k][
i][0] =
W[buf_idx][
i + i_f - t_HFGen][k][0];
1276 X_low[k][
i][1] =
W[buf_idx][
i + i_f - t_HFGen][k][1];
1286 const INTFLOAT bw_array[5],
const uint8_t *t_env,
1301 "ERROR : no subband found for frequency %d\n", k);
1307 alpha0[p], alpha1[p], bw_array[
g],
1308 2 * t_env[0], 2 * t_env[bs_num_env]);
1311 if (k < sbr->m[1] + sbr->
kx[1])
1312 memset(X_high + k, 0, (sbr->
m[1] + sbr->
kx[1] - k) *
sizeof(*X_high));
1320 const INTFLOAT X_low[32][40][2],
int ch)
1325 memset(
X, 0, 2*
sizeof(*
X));
1326 for (k = 0; k < sbr->
kx[0]; k++) {
1327 for (
i = 0;
i < i_Temp;
i++) {
1332 for (; k < sbr->
kx[0] + sbr->
m[0]; k++) {
1333 for (
i = 0;
i < i_Temp;
i++) {
1334 X[0][
i][k] = Y0[
i + i_f][k][0];
1335 X[1][
i][k] = Y0[
i + i_f][k][1];
1339 for (k = 0; k < sbr->
kx[1]; k++) {
1340 for (
i = i_Temp;
i < 38;
i++) {
1345 for (; k < sbr->
kx[1] + sbr->
m[1]; k++) {
1346 for (
i = i_Temp;
i < i_f;
i++) {
1347 X[0][
i][k] = Y1[
i][k][0];
1348 X[1][
i][k] = Y1[
i][k][1];
1364 const unsigned int ilim = sbr->
n[ch_data->
bs_freq_res[e + 1]];
1370 "Derived frequency tables were not regenerated.\n");
1374 for (
i = 0;
i < ilim;
i++)
1380 for (
i = 0;
i < sbr->
n_q;
i++)
1381 for (m = sbr->
f_tablenoise[
i]; m < sbr->f_tablenoise[
i + 1]; m++)
1384 for (
i = 0;
i < sbr->
n[1];
i++) {
1386 const unsigned int m_midpoint =
1390 (e >= e_a[1] || (ch_data->
s_indexmapped[0][m_midpoint - sbr->
kx[1]] == 1));
1394 for (
i = 0;
i < ilim;
i++) {
1395 int additional_sinusoid_present = 0;
1398 additional_sinusoid_present = 1;
1402 memset(&sbr->
s_mapped[e][
table[
i] - sbr->
kx[1]], additional_sinusoid_present,
1416 int kx1 = sbr->
kx[1];
1423 const float recip_env_size = 0.5f / (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1428 for (m = 0; m < sbr->
m[1]; m++) {
1431 e_curr[e][m] =
av_mul_sf(sum, recip_env_size);
1433 e_curr[e][m] = sum * recip_env_size;
1441 const int env_size = 2 * (ch_data->
t_env[e + 1] - ch_data->
t_env[e]);
1446 for (p = 0; p < sbr->
n[ch_data->
bs_freq_res[e + 1]]; p++) {
1456 const int den = env_size * (
table[p + 1] -
table[p]);
1464 e_curr[e][k - kx1] = sum;
1475 int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->
sample_rate;
1477 int nch = (id_aac ==
TYPE_CPE) ? 2 : 1;
1480 if (id_aac != sbr->
id_aac) {
1482 "element type mismatch %d != %d\n", id_aac, sbr->
id_aac);
1488 "No quantized data read for sbr_dequant.\n");
1493 sbr->
kx[0] = sbr->
kx[1];
1494 sbr->
m[0] = sbr->
m[1];
1503 for (ch = 0; ch < nch; ch++) {
1532 sbr, &sbr->
data[ch],
1544 if (ac->oc[1].m4ac.ps == 1) {
1548 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)
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]
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
AAC_FLOAT env_facs[6][48]
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
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.
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)
uint8_t t_env[8]
Envelope time borders.
INTFLOAT X_low[32][40][2]
QMF low frequency input to the HF generator.
static int qsort_comparison_function_int16(const void *a, const void *b)
SingleChannelElement ch[2]
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)
@ T_HUFFMAN_ENV_BAL_3_0DB
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.
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
@ F_HUFFMAN_ENV_BAL_3_0DB
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)
static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
#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.
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.
uint8_t env_facs_q[6][48]
Envelope scalefactors.
uint16_t f_tablelow[25]
Frequency borders for low resolution SBR.
static const SoftFloat FLOAT_0
0.0
static int 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.
uint8_t s_indexmapped[8][48]
static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read how the envelope and noise floor data is delta coded.
unsigned bs_smoothing_mode
static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64], const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2], const INTFLOAT X_low[32][40][2], int ch)
Generate the subband filtered lowband.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Spectral Band Replication header - spectrum parameters that invoke a reset if they differ from the pr...
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.
@ T_HUFFMAN_ENV_BAL_1_5DB
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
void AAC_RENAME() ff_aac_sbr_apply(AACDecContext *ac, ChannelElement *che, int id_aac, INTFLOAT *L, INTFLOAT *R)
Apply one SBR element to one AAC element.
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)
AAC_FLOAT e_curr[7][48]
Estimated envelope.
static const int CONST_RECIP_LN2
#define i(width, name, range_min, range_max)
static const int8_t ceil_log2[]
ceil(log2(index+1))
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
@ F_HUFFMAN_ENV_BAL_1_5DB
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]
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
static int array_min_int16(const int16_t *array, int nel)
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)
@ T_HUFFMAN_NOISE_BAL_3_0DB
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
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
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.