FFmpeg
Loading...
Searching...
No Matches
aacsbr_template.c
Go to the documentation of this file.
1/*
2 * AAC Spectral Band Replication decoding functions
3 * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
4 * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
5 *
6 * Fixed point code
7 * Copyright (c) 2013
8 * MIPS Technologies, Inc., California.
9 *
10 * This file is part of FFmpeg.
11 *
12 * FFmpeg is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * FFmpeg is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with FFmpeg; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 */
26
27/**
28 * @file
29 * AAC Spectral Band Replication decoding functions
30 * @author Robert Swain ( rob opendot cl )
31 * @author Stanislav Ocovaj ( stanislav.ocovaj@imgtec.com )
32 * @author Zoran Basaric ( zoran.basaric@imgtec.com )
33 */
34
35#include "aac/aacdec.h"
36#include "aac/aacdec_tab.h"
37#include "avcodec.h"
38#include "libavutil/qsort.h"
39#include "libavutil/mem.h"
40
46
48{
49 return &((ExtChannelElement*)ch)->sbr;
50}
51
56
57/** Places SBR in pure upsampling mode. */
59 sbr->start = 0;
60 sbr->usac = 0;
61 sbr->ready_for_dequant = 0;
62 // Init defaults used in pure upsampling mode
63 sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
64 sbr->m[1] = 0;
65 // Reset values for first SBR header
66 sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
67 memset(&sbr->spectrum_params, -1, sizeof(SpectrumParameters));
68}
69
71 ChannelElement **che, int id_aac)
72{
74 ExtChannelElement *ext = av_mallocz(sizeof(*ext));
75 int ret;
76 float scale;
77
78 if (!ext)
79 return AVERROR(ENOMEM);
80 sbr = &ext->sbr;
81 ext->ch.ch[0].AAC_RENAME(predictor_state) = ext->predictor_state[0];
82 ext->ch.ch[1].AAC_RENAME(predictor_state) = ext->predictor_state[1];
83
84 sbr->kx[0] = sbr->kx[1];
85 sbr->id_aac = id_aac;
86 sbr_turnoff(sbr);
89 /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
90 * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
91 * and scale back down at synthesis. */
92
93 scale = USE_FIXED ? 1 : 1.0 / (64 * 32768);
94 ret = av_tx_init(&sbr->mdct, &sbr->mdct_fn,
96 1, 64, &scale, 0);
97 if (ret < 0)
98 goto fail;
99
100 scale = USE_FIXED ? -1.0 : -2.0 * 32768;
101 ret = av_tx_init(&sbr->mdct_ana, &sbr->mdct_ana_fn,
103 1, 64, &scale, 0);
104 if (ret < 0)
105 goto fail;
106
109 aacsbr_func_ptr_init(&sbr->c);
110
111 *che = &ext->ch;
112 return 0;
113fail:
114 av_tx_uninit(&sbr->mdct);
115 av_free(ext);
116 return ret;
117}
118
125
127{
129 int id_aac = sbr->id_aac;
130
131 /* Discard all inter-frame state. The transform contexts (mdct_ana,
132 * mdct) and the function pointer tables (dsp, c) at the end of the
133 * struct are set up once in ff_aac_sbr_ctx_alloc_init() and hold no
134 * stream state, so they are deliberately left untouched. */
135 memset(sbr, 0, offsetof(SpectralBandReplication, mdct_ana));
136
137 sbr->id_aac = id_aac;
138 sbr_turnoff(sbr);
142}
143
144static int qsort_comparison_function_int16(const void *a, const void *b)
145{
146 return *(const int16_t *)a - *(const int16_t *)b;
147}
148
149static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle)
150{
151 int i;
152 for (i = 0; i <= last_el; i++)
153 if (table[i] == needle)
154 return 1;
155 return 0;
156}
157
158/// Limiter Frequency Band Table (14496-3 sp04 p198)
160{
161 int k;
162 if (sbr->bs_limiter_bands > 0) {
163 static const INTFLOAT bands_warped[3] = { Q23(1.32715174233856803909f), //2^(0.49/1.2)
164 Q23(1.18509277094158210129f), //2^(0.49/2)
165 Q23(1.11987160404675912501f) }; //2^(0.49/3)
166 const INTFLOAT lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
167 int16_t patch_borders[7];
168 uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
169
170 patch_borders[0] = sbr->kx[1];
171 for (k = 1; k <= sbr->num_patches; k++)
172 patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
173
174 memcpy(sbr->f_tablelim, sbr->f_tablelow,
175 (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
176 if (sbr->num_patches > 1)
177 memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
178 (sbr->num_patches - 1) * sizeof(patch_borders[0]));
179
180 AV_QSORT(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
181 uint16_t,
183
184 sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
185 while (out < sbr->f_tablelim + sbr->n_lim) {
186#if USE_FIXED
187 if ((*in << 23) >= *out * lim_bands_per_octave_warped) {
188#else
189 if (*in >= *out * lim_bands_per_octave_warped) {
190#endif /* USE_FIXED */
191 *++out = *in++;
192 } else if (*in == *out ||
193 !in_table_int16(patch_borders, sbr->num_patches, *in)) {
194 in++;
195 sbr->n_lim--;
196 } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
197 *out = *in++;
198 sbr->n_lim--;
199 } else {
200 *++out = *in++;
201 }
202 }
203 } else {
204 sbr->f_tablelim[0] = sbr->f_tablelow[0];
205 sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
206 sbr->n_lim = 1;
207 }
208}
209
211 GetBitContext *gb, int is_usac)
212{
213 unsigned int cnt = get_bits_count(gb);
214 uint8_t bs_header_extra_1;
215 uint8_t bs_header_extra_2;
216 int old_bs_limiter_bands = sbr->bs_limiter_bands;
217 SpectrumParameters old_spectrum_params;
218
219 sbr->start = 1;
220 sbr->ready_for_dequant = 0;
221 sbr->usac = is_usac;
222
223 // Save last spectrum parameters variables to compare to new ones
224 memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
225
226 if (!is_usac)
227 sbr->bs_amp_res_header = get_bits1(gb);
228
231
232 if (!is_usac)
234 skip_bits(gb, 2); // bs_reserved
235
236 bs_header_extra_1 = get_bits1(gb);
237 bs_header_extra_2 = get_bits1(gb);
238
239 if (bs_header_extra_1) {
243 } else {
247 }
248
249 // Check if spectrum parameters changed
250 if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
251 sbr->reset = 1;
252
253 if (bs_header_extra_2) {
254 sbr->bs_limiter_bands = get_bits(gb, 2);
255 sbr->bs_limiter_gains = get_bits(gb, 2);
256 sbr->bs_interpol_freq = get_bits1(gb);
257 sbr->bs_smoothing_mode = get_bits1(gb);
258 } else {
259 sbr->bs_limiter_bands = 2;
260 sbr->bs_limiter_gains = 2;
261 sbr->bs_interpol_freq = 1;
262 sbr->bs_smoothing_mode = 1;
263 }
264
265 if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
267
268 return get_bits_count(gb) - cnt;
269}
270
271static int array_min_int16(const int16_t *array, int nel)
272{
273 int i, min = array[0];
274 for (i = 1; i < nel; i++)
275 min = FFMIN(array[i], min);
276 return min;
277}
278
279static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
280{
281 // Requirements (14496-3 sp04 p205)
282 if (n_master <= 0) {
283 av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
284 return -1;
285 }
286 if (bs_xover_band >= n_master) {
287 av_log(avctx, AV_LOG_ERROR,
288 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
289 bs_xover_band);
290 return -1;
291 }
292 return 0;
293}
294
295/// Master Frequency Band Table (14496-3 sp04 p194)
297 SpectrumParameters *spectrum)
298{
299 unsigned int temp, max_qmf_subbands = 0;
300 unsigned int start_min, stop_min;
301 int k;
302 const int8_t *sbr_offset_ptr;
303 int16_t stop_dk[13];
304
305 switch (sbr->sample_rate) {
306 case 16000:
307 sbr_offset_ptr = sbr_offset[0];
308 break;
309 case 22050:
310 sbr_offset_ptr = sbr_offset[1];
311 break;
312 case 24000:
313 sbr_offset_ptr = sbr_offset[2];
314 break;
315 case 32000:
316 sbr_offset_ptr = sbr_offset[3];
317 break;
318 case 44100: case 48000: case 64000:
319 sbr_offset_ptr = sbr_offset[4];
320 break;
321 case 88200: case 96000: case 128000: case 176400: case 192000:
322 sbr_offset_ptr = sbr_offset[5];
323 break;
324 default:
326 "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
327 return -1;
328 }
329
330 if (sbr->sample_rate < 32000) {
331 temp = 3000;
332 } else if (sbr->sample_rate < 64000) {
333 temp = 4000;
334 } else
335 temp = 5000;
336
337 start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
338 stop_min = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
339
340 sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
341
342 if (spectrum->bs_stop_freq < 14) {
343 sbr->k[2] = stop_min;
344 make_bands(stop_dk, stop_min, 64, 13);
345 AV_QSORT(stop_dk, 13, int16_t, qsort_comparison_function_int16);
346 for (k = 0; k < spectrum->bs_stop_freq; k++)
347 sbr->k[2] += stop_dk[k];
348 } else if (spectrum->bs_stop_freq == 14) {
349 sbr->k[2] = 2*sbr->k[0];
350 } else if (spectrum->bs_stop_freq == 15) {
351 sbr->k[2] = 3*sbr->k[0];
352 } else {
354 "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);
355 return -1;
356 }
357 sbr->k[2] = FFMIN(64, sbr->k[2]);
358
359 // Requirements (14496-3 sp04 p205)
360 if (sbr->sample_rate <= 32000) {
361 max_qmf_subbands = 48;
362 } else if (sbr->sample_rate == 44100) {
363 max_qmf_subbands = 35;
364 } else if (sbr->sample_rate >= 48000)
365 max_qmf_subbands = 32;
366 else
367 av_assert0(0);
368
369 if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
371 "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
372 return -1;
373 }
374
375 if (!spectrum->bs_freq_scale) {
376 int dk, k2diff;
377
378 dk = spectrum->bs_alter_scale + 1;
379 sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
381 return -1;
382
383 for (k = 1; k <= sbr->n_master; k++)
384 sbr->f_master[k] = dk;
385
386 k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
387 if (k2diff < 0) {
388 sbr->f_master[1]--;
389 sbr->f_master[2]-= (k2diff < -1);
390 } else if (k2diff) {
391 sbr->f_master[sbr->n_master]++;
392 }
393
394 sbr->f_master[0] = sbr->k[0];
395 for (k = 1; k <= sbr->n_master; k++)
396 sbr->f_master[k] += sbr->f_master[k - 1];
397
398 } else {
399 int half_bands = 7 - spectrum->bs_freq_scale; // bs_freq_scale = {1,2,3}
400 int two_regions, num_bands_0;
401 int vdk0_max, vdk1_min;
402 int16_t vk0[49];
403#if USE_FIXED
404 int tmp, nz = 0;
405#endif /* USE_FIXED */
406
407 if (49 * sbr->k[2] > 110 * sbr->k[0]) {
408 two_regions = 1;
409 sbr->k[1] = 2 * sbr->k[0];
410 } else {
411 two_regions = 0;
412 sbr->k[1] = sbr->k[2];
413 }
414
415#if USE_FIXED
416 tmp = (sbr->k[1] << 23) / sbr->k[0];
417 while (tmp < 0x40000000) {
418 tmp <<= 1;
419 nz++;
420 }
421 tmp = fixed_log(tmp - 0x80000000);
422 tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30);
423 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
424 num_bands_0 = ((tmp + 0x400000) >> 23) * 2;
425#else
426 num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
427#endif /* USE_FIXED */
428
429 if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)
430 av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
431 return -1;
432 }
433
434 vk0[0] = 0;
435
436 make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
437
438 AV_QSORT(vk0 + 1, num_bands_0, int16_t, qsort_comparison_function_int16);
439 vdk0_max = vk0[num_bands_0];
440
441 vk0[0] = sbr->k[0];
442 for (k = 1; k <= num_bands_0; k++) {
443 if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)
444 av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
445 return -1;
446 }
447 vk0[k] += vk0[k-1];
448 }
449
450 if (two_regions) {
451 int16_t vk1[49];
452#if USE_FIXED
453 int num_bands_1;
454
455 tmp = (sbr->k[2] << 23) / sbr->k[1];
456 nz = 0;
457 while (tmp < 0x40000000) {
458 tmp <<= 1;
459 nz++;
460 }
461 tmp = fixed_log(tmp - 0x80000000);
462 tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30);
463 tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
464 if (spectrum->bs_alter_scale)
465 tmp = (int)(((int64_t)tmp * CONST_076923 + 0x40000000) >> 31);
466 num_bands_1 = ((tmp + 0x400000) >> 23) * 2;
467#else
468 float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f
469 : 1.0f; // bs_alter_scale = {0,1}
470 int num_bands_1 = lrintf(half_bands * invwarp *
471 log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
472#endif /* USE_FIXED */
473 make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
474
475 vdk1_min = array_min_int16(vk1 + 1, num_bands_1);
476
477 if (vdk1_min < vdk0_max) {
478 int change;
479 AV_QSORT(vk1 + 1, num_bands_1, int16_t, qsort_comparison_function_int16);
480 change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
481 vk1[1] += change;
482 vk1[num_bands_1] -= change;
483 }
484
485 AV_QSORT(vk1 + 1, num_bands_1, int16_t, qsort_comparison_function_int16);
486
487 vk1[0] = sbr->k[1];
488 for (k = 1; k <= num_bands_1; k++) {
489 if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)
490 av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
491 return -1;
492 }
493 vk1[k] += vk1[k-1];
494 }
495
496 sbr->n_master = num_bands_0 + num_bands_1;
498 return -1;
499 memcpy(&sbr->f_master[0], vk0,
500 (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
501 memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
502 num_bands_1 * sizeof(sbr->f_master[0]));
503
504 } else {
505 sbr->n_master = num_bands_0;
507 return -1;
508 memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
509 }
510 }
511
512 return 0;
513}
514
515/// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
517{
518 int i, k, last_k = -1, last_msb = -1, sb = 0;
519 int msb = sbr->k[0];
520 int usb = sbr->kx[1];
521 int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
522
523 sbr->num_patches = 0;
524
525 if (goal_sb < sbr->kx[1] + sbr->m[1]) {
526 for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
527 } else
528 k = sbr->n_master;
529
530 do {
531 int odd = 0;
532 if (k == last_k && msb == last_msb) {
533 av_log(ac->avctx, AV_LOG_ERROR, "patch construction failed\n");
534 return AVERROR_INVALIDDATA;
535 }
536 last_k = k;
537 last_msb = msb;
538 for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
539 sb = sbr->f_master[i];
540 odd = (sb + sbr->k[0]) & 1;
541 }
542
543 // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
544 // After this check the final number of patches can still be six which is
545 // illegal however the Coding Technologies decoder check stream has a final
546 // count of 6 patches
547 if (sbr->num_patches > 5) {
548 av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
549 return -1;
550 }
551
552 sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0);
553 sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
554
555 if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
556 usb = sb;
557 msb = sb;
558 sbr->num_patches++;
559 } else
560 msb = sbr->kx[1];
561
562 if (sbr->f_master[k] - sb < 3)
563 k = sbr->n_master;
564 } while (sb != sbr->kx[1] + sbr->m[1]);
565
566 if (sbr->num_patches > 1 &&
567 sbr->patch_num_subbands[sbr->num_patches - 1] < 3)
568 sbr->num_patches--;
569
570 return 0;
571}
572
573/// Derived Frequency Band Tables (14496-3 sp04 p197)
575{
576 int k, temp;
577#if USE_FIXED
578 int nz = 0;
579#endif /* USE_FIXED */
580
581 sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
582 sbr->n[0] = (sbr->n[1] + 1) >> 1;
583
584 memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
585 (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
586 sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
587 sbr->kx[1] = sbr->f_tablehigh[0];
588
589 // Requirements (14496-3 sp04 p205)
590 if (sbr->kx[1] + sbr->m[1] > 64) {
592 "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
593 return -1;
594 }
595 if (sbr->kx[1] > 32) {
596 av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
597 return -1;
598 }
599
600 sbr->f_tablelow[0] = sbr->f_tablehigh[0];
601 temp = sbr->n[1] & 1;
602 for (k = 1; k <= sbr->n[0]; k++)
603 sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
604#if USE_FIXED
605 temp = (sbr->k[2] << 23) / sbr->kx[1];
606 while (temp < 0x40000000) {
607 temp <<= 1;
608 nz++;
609 }
610 temp = fixed_log(temp - 0x80000000);
611 temp = (int)(((int64_t)temp * CONST_RECIP_LN2 + 0x20000000) >> 30);
612 temp = (((temp + 0x80) >> 8) + ((8 - nz) << 23)) * sbr->spectrum_params.bs_noise_bands;
613
614 sbr->n_q = (temp + 0x400000) >> 23;
615 if (sbr->n_q < 1)
616 sbr->n_q = 1;
617#else
619 log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
620#endif /* USE_FIXED */
621
622 if (sbr->n_q > 5) {
623 av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
624 sbr->n_q = 1;
625 return -1;
626 }
627
628 sbr->f_tablenoise[0] = sbr->f_tablelow[0];
629 temp = 0;
630 for (k = 1; k <= sbr->n_q; k++) {
631 temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
632 sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
633 }
634
635 if (sbr_hf_calc_npatches(ac, sbr) < 0)
636 return -1;
637
639
640 sbr->data[0].f_indexnoise = 0;
641 sbr->data[1].f_indexnoise = 0;
642
643 return 0;
644}
645
646static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec,
647 int elements)
648{
649 int i;
650 for (i = 0; i < elements; i++) {
651 vec[i] = get_bits1(gb);
652 }
653}
654
655/** ceil(log2(index+1)) */
656static const int8_t ceil_log2[] = {
657 0, 1, 2, 2, 3, 3,
658};
659
661 GetBitContext *gb, SBRData *ch_data, int numTimeSlots)
662{
663 int i;
664 int bs_pointer = 0;
665 int abs_bord_trail = numTimeSlots;
666 int num_rel_lead, num_rel_trail;
667 unsigned bs_num_env_old = ch_data->bs_num_env;
668 int bs_frame_class, bs_num_env;
669
670 ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
671 ch_data->bs_amp_res = sbr->bs_amp_res_header;
672 ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
673
674 switch (bs_frame_class = get_bits(gb, 2)) {
675 case FIXFIX:
676 bs_num_env = 1 << get_bits(gb, 2);
677 if (bs_num_env > (sbr->usac ? 8 : 5)) {
679 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
680 bs_num_env);
681 return -1;
682 }
683 ch_data->bs_num_env = bs_num_env;
684 num_rel_lead = ch_data->bs_num_env - 1;
685 if (ch_data->bs_num_env == 1)
686 ch_data->bs_amp_res = 0;
687
688
689 ch_data->t_env[0] = 0;
690 ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
691
692 abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) /
693 ch_data->bs_num_env;
694 for (i = 0; i < num_rel_lead; i++)
695 ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail;
696
697 ch_data->bs_freq_res[1] = get_bits1(gb);
698 for (i = 1; i < ch_data->bs_num_env; i++)
699 ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1];
700 break;
701 case FIXVAR:
702 abs_bord_trail += get_bits(gb, 2);
703 num_rel_trail = get_bits(gb, 2);
704 ch_data->bs_num_env = num_rel_trail + 1;
705 ch_data->t_env[0] = 0;
706 ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
707
708 for (i = num_rel_trail; i > 0; i--)
709 ch_data->t_env[i] = ch_data->t_env[i + 1] - 2 * get_bits(gb, 2) - 2;
710
711 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
712
713 for (i = 0; i < ch_data->bs_num_env; i++)
714 ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb);
715 break;
716 case VARFIX:
717 ch_data->t_env[0] = get_bits(gb, 2);
718 num_rel_lead = get_bits(gb, 2);
719 ch_data->bs_num_env = num_rel_lead + 1;
720 ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
721
722 for (i = 0; i < num_rel_lead; i++)
723 ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
724
725 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
726
727 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
728 break;
729 case VARVAR:
730 ch_data->t_env[0] = get_bits(gb, 2);
731 abs_bord_trail += get_bits(gb, 2);
732 num_rel_lead = get_bits(gb, 2);
733 num_rel_trail = get_bits(gb, 2);
734 bs_num_env = num_rel_lead + num_rel_trail + 1;
735
736 if (bs_num_env > 5) {
738 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
739 bs_num_env);
740 return -1;
741 }
742 /* Make the bounds implied by the two-bit counts explicit for GCC. */
743 if (bs_num_env < 1 || num_rel_trail < 0 || num_rel_trail >= bs_num_env)
744 return AVERROR_INVALIDDATA;
745 ch_data->bs_num_env = bs_num_env;
746
747 ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
748
749 for (i = 0; i < num_rel_lead; i++)
750 ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
751 for (i = bs_num_env - 1; i >= bs_num_env - num_rel_trail; i--)
752 ch_data->t_env[i] = ch_data->t_env[i + 1] - 2 * get_bits(gb, 2) - 2;
753
754 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
755
756 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
757 break;
758 }
759 ch_data->bs_frame_class = bs_frame_class;
760
761 av_assert0(bs_pointer >= 0);
762 if (bs_pointer > ch_data->bs_num_env + 1) {
764 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
765 bs_pointer);
766 return -1;
767 }
768
769 for (i = 1; i <= ch_data->bs_num_env; i++) {
770 if (ch_data->t_env[i-1] >= ch_data->t_env[i]) {
771 av_log(ac->avctx, AV_LOG_ERROR, "Not strictly monotone time borders\n");
772 return -1;
773 }
774 }
775
776 ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1;
777
778 ch_data->t_q[0] = ch_data->t_env[0];
779 ch_data->t_q[ch_data->bs_num_noise] = ch_data->t_env[ch_data->bs_num_env];
780 if (ch_data->bs_num_noise > 1) {
781 int idx;
782 if (ch_data->bs_frame_class == FIXFIX) {
783 idx = ch_data->bs_num_env >> 1;
784 } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
785 idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1);
786 } else { // VARFIX
787 if (!bs_pointer)
788 idx = 1;
789 else if (bs_pointer == 1)
790 idx = ch_data->bs_num_env - 1;
791 else // bs_pointer > 1
792 idx = bs_pointer - 1;
793 }
794 ch_data->t_q[1] = ch_data->t_env[idx];
795 }
796
797 ch_data->e_a[0] = -(ch_data->e_a[1] != bs_num_env_old); // l_APrev
798 ch_data->e_a[1] = -1;
799 if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0
800 ch_data->e_a[1] = ch_data->bs_num_env + 1 - bs_pointer;
801 } else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1
802 ch_data->e_a[1] = bs_pointer - 1;
803
804 return 0;
805}
806
807static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
808 //These variables are saved from the previous frame rather than copied
809 dst->bs_freq_res[0] = dst->bs_freq_res[dst->bs_num_env];
810 dst->t_env_num_env_old = dst->t_env[dst->bs_num_env];
811 dst->e_a[0] = -(dst->e_a[1] != dst->bs_num_env);
812
813 //These variables are read from the bitstream and therefore copied
814 memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res));
815 memcpy(dst->t_env, src->t_env, sizeof(dst->t_env));
816 memcpy(dst->t_q, src->t_q, sizeof(dst->t_q));
817 dst->bs_num_env = src->bs_num_env;
818 dst->bs_amp_res = src->bs_amp_res;
819 dst->bs_num_noise = src->bs_num_noise;
820 dst->bs_frame_class = src->bs_frame_class;
821 dst->e_a[1] = src->e_a[1];
822}
823
824/// Read how the envelope and noise floor data is delta coded
826 SBRData *ch_data, int indep_flag)
827{
828 if (sbr->usac) {
829 if (indep_flag) {
830 ch_data->bs_df_env[0] = 0;
831 get_bits1_vector(gb, &ch_data->bs_df_env[1], ch_data->bs_num_env - 1);
832 } else {
833 get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
834 }
835
836 if (indep_flag) {
837 ch_data->bs_df_noise[0] = 0;
838 get_bits1_vector(gb, &ch_data->bs_df_noise[1], ch_data->bs_num_noise - 1);
839 } else {
840 get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
841 }
842 } else {
843 get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
844 get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
845 }
846}
847
848/// Read inverse filtering data
850 SBRData *ch_data)
851{
852 int i;
853
854 memcpy(ch_data->bs_invf_mode[1], ch_data->bs_invf_mode[0], 5 * sizeof(uint8_t));
855 for (i = 0; i < sbr->n_q; i++)
856 ch_data->bs_invf_mode[0][i] = get_bits(gb, 2);
857}
858
860 SBRData *ch_data, int ch)
861{
862 int bits;
863 int i, j, k;
864 const VLCElem *t_huff, *f_huff;
865 const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
866 const int odd = sbr->n[1] & 1;
867
868 if (sbr->bs_coupling && ch) {
869 if (ch_data->bs_amp_res) {
870 bits = 5;
873 } else {
874 bits = 6;
877 }
878 } else {
879 if (ch_data->bs_amp_res) {
880 bits = 6;
883 } else {
884 bits = 7;
887 }
888 }
889
890 for (i = 0; i < ch_data->bs_num_env; i++) {
891 if (ch_data->bs_df_env[i]) {
892 // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
893 if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
894 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
895 ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][j] + delta * get_vlc2(gb, t_huff, 9, 3);
896 if (ch_data->env_facs_q[i + 1][j] > 127U) {
897 av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
898 return AVERROR_INVALIDDATA;
899 }
900 }
901 } else if (ch_data->bs_freq_res[i + 1]) {
902 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
903 k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
904 ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][k] + delta * get_vlc2(gb, t_huff, 9, 3);
905 if (ch_data->env_facs_q[i + 1][j] > 127U) {
906 av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
907 return AVERROR_INVALIDDATA;
908 }
909 }
910 } else {
911 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
912 k = j ? 2*j - odd : 0; // find k such that f_tablehigh[k] == f_tablelow[j]
913 ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][k] + delta * get_vlc2(gb, t_huff, 9, 3);
914 if (ch_data->env_facs_q[i + 1][j] > 127U) {
915 av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
916 return AVERROR_INVALIDDATA;
917 }
918 }
919 }
920 } else {
921 ch_data->env_facs_q[i + 1][0] = delta * get_bits(gb, bits); // bs_env_start_value_balance
922 for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
923 ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i + 1][j - 1] + delta * get_vlc2(gb, f_huff, 9, 3);
924 if (ch_data->env_facs_q[i + 1][j] > 127U) {
925 av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
926 return AVERROR_INVALIDDATA;
927 }
928 }
929 }
930 if (sbr->usac) {
931 if (sbr->inter_tes) {
932 ch_data->temp_shape[i] = get_bits(gb, 1);
933 if (ch_data->temp_shape[i])
934 ch_data->temp_shape_mode[i] = get_bits(gb, 2);
935 }
936 }
937 }
938
939 //assign 0th elements of env_facs_q from last elements
940 memcpy(ch_data->env_facs_q[0], ch_data->env_facs_q[ch_data->bs_num_env],
941 sizeof(ch_data->env_facs_q[0]));
942
943 return 0;
944}
945
947 SBRData *ch_data, int ch)
948{
949 int i, j;
950 const VLCElem *t_huff, *f_huff;
951 int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
952
953 if (sbr->bs_coupling && ch) {
956 } else {
959 }
960
961 for (i = 0; i < ch_data->bs_num_noise; i++) {
962 if (ch_data->bs_df_noise[i]) {
963 for (j = 0; j < sbr->n_q; j++) {
964 ch_data->noise_facs_q[i + 1][j] = ch_data->noise_facs_q[i][j] + delta * get_vlc2(gb, t_huff, 9, 2);
965 if (ch_data->noise_facs_q[i + 1][j] > 30U) {
966 av_log(ac->avctx, AV_LOG_ERROR, "noise_facs_q %d is invalid\n", ch_data->noise_facs_q[i + 1][j]);
967 return AVERROR_INVALIDDATA;
968 }
969 }
970 } else {
971 ch_data->noise_facs_q[i + 1][0] = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
972 for (j = 1; j < sbr->n_q; j++) {
973 ch_data->noise_facs_q[i + 1][j] = ch_data->noise_facs_q[i + 1][j - 1] + delta * get_vlc2(gb, f_huff, 9, 3);
974 if (ch_data->noise_facs_q[i + 1][j] > 30U) {
975 av_log(ac->avctx, AV_LOG_ERROR, "noise_facs_q %d is invalid\n", ch_data->noise_facs_q[i + 1][j]);
976 return AVERROR_INVALIDDATA;
977 }
978 }
979 }
980 }
981
982 //assign 0th elements of noise_facs_q from last elements
983 memcpy(ch_data->noise_facs_q[0], ch_data->noise_facs_q[ch_data->bs_num_noise],
984 sizeof(ch_data->noise_facs_q[0]));
985 return 0;
986}
987
989 GetBitContext *gb,
990 int bs_extension_id, int *num_bits_left)
991{
992 switch (bs_extension_id) {
993 case EXTENSION_ID_PS:
994 if (!ac->oc[1].m4ac.ps) {
995 av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
996 skip_bits_long(gb, *num_bits_left); // bs_fill_bits
997 *num_bits_left = 0;
998 } else {
999 *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps.common, *num_bits_left);
1001 // ensure the warning is not printed if PS extension is present
1002 ac->warned_he_aac_mono = 1;
1003 }
1004 break;
1005 default:
1006 // some files contain 0-padding
1007 if (bs_extension_id || *num_bits_left > 16 || show_bits(gb, *num_bits_left))
1008 avpriv_request_sample(ac->avctx, "Reserved SBR extensions");
1009 skip_bits_long(gb, *num_bits_left); // bs_fill_bits
1010 *num_bits_left = 0;
1011 break;
1012 }
1013}
1014
1017 GetBitContext *gb, int numTimeSlots)
1018{
1019 int ret;
1020
1021 if (get_bits1(gb)) // bs_data_extra
1022 skip_bits(gb, 4); // bs_reserved
1023
1024 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0], numTimeSlots))
1025 return -1;
1026 read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
1027 read_sbr_invf(sbr, gb, &sbr->data[0]);
1028 if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1029 return ret;
1030 if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1031 return ret;
1032
1033 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
1034 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
1035
1036 return 0;
1037}
1038
1041 GetBitContext *gb, int numTimeSlots)
1042{
1043 int ret;
1044
1045 if (get_bits1(gb)) // bs_data_extra
1046 skip_bits(gb, 8); // bs_reserved
1047
1048 if ((sbr->bs_coupling = get_bits1(gb))) {
1049 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0], numTimeSlots))
1050 return -1;
1051 copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
1052 read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
1053 read_sbr_dtdf(sbr, gb, &sbr->data[1], 0);
1054 read_sbr_invf(sbr, gb, &sbr->data[0]);
1055 memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
1056 memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
1057 if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1058 return ret;
1059 if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1060 return ret;
1061 if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1062 return ret;
1063 if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1064 return ret;
1065 } else {
1066 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0], numTimeSlots) ||
1067 read_sbr_grid(ac, sbr, gb, &sbr->data[1], numTimeSlots))
1068 return -1;
1069 read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
1070 read_sbr_dtdf(sbr, gb, &sbr->data[1], 0);
1071 read_sbr_invf(sbr, gb, &sbr->data[0]);
1072 read_sbr_invf(sbr, gb, &sbr->data[1]);
1073 if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1074 return ret;
1075 if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1076 return ret;
1077 if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1078 return ret;
1079 if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1080 return ret;
1081 }
1082
1083 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
1084 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
1085 if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
1086 get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
1087
1088 return 0;
1089}
1090
1092 GetBitContext *gb, int id_aac, int numTimeSlots)
1093{
1094 unsigned int cnt = get_bits_count(gb);
1095
1096 sbr->id_aac = id_aac;
1097 sbr->ready_for_dequant = 1;
1098
1099 if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
1100 if (read_sbr_single_channel_element(ac, sbr, gb, numTimeSlots)) {
1101 sbr_turnoff(sbr);
1102 return get_bits_count(gb) - cnt;
1103 }
1104 } else if (id_aac == TYPE_CPE) {
1105 if (read_sbr_channel_pair_element(ac, sbr, gb, numTimeSlots)) {
1106 sbr_turnoff(sbr);
1107 return get_bits_count(gb) - cnt;
1108 }
1109 } else {
1111 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1112 sbr_turnoff(sbr);
1113 return get_bits_count(gb) - cnt;
1114 }
1115 if (get_bits1(gb)) { // bs_extended_data
1116 int num_bits_left = get_bits(gb, 4); // bs_extension_size
1117 if (num_bits_left == 15)
1118 num_bits_left += get_bits(gb, 8); // bs_esc_count
1119
1120 num_bits_left <<= 3;
1121 while (num_bits_left > 7) {
1122 num_bits_left -= 2;
1123 read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id
1124 }
1125 if (num_bits_left < 0) {
1126 av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n");
1127 }
1128 if (num_bits_left > 0)
1129 skip_bits(gb, num_bits_left);
1130 }
1131
1132 return get_bits_count(gb) - cnt;
1133}
1134
1136{
1137 int err;
1138 err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params);
1139 if (err >= 0)
1140 err = sbr_make_f_derived(ac, sbr);
1141 if (err < 0) {
1143 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1144 sbr_turnoff(sbr);
1145 }
1146}
1147
1148/**
1149 * Decode Spectral Band Replication extension data; reference: table 4.55.
1150 *
1151 * @param crc flag indicating the presence of CRC checksum
1152 * @param cnt length of TYPE_FIL syntactic element in bytes
1153 *
1154 * @return Returns number of bytes consumed from the TYPE_FIL element.
1155 */
1157 GetBitContext *gb_host, int crc,
1158 int cnt, int id_aac, int fl960)
1159{
1160 SpectralBandReplication *sbr = get_sbr(che);
1161 unsigned int num_sbr_bits = 0, num_align_bits;
1162 unsigned bytes_read;
1163 GetBitContext gbc = *gb_host, *gb = &gbc;
1164 int numTimeSlots = fl960 ? 15 : 16;
1165 skip_bits_long(gb_host, cnt*8 - 4);
1166
1167 sbr->reset = 0;
1168
1169 if (!sbr->sample_rate)
1170 sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
1171 if (!ac->oc[1].m4ac.ext_sample_rate)
1172 ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1173
1174 if (crc) {
1175 skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check
1176 num_sbr_bits += 10;
1177 }
1178
1179 //Save some state from the previous frame.
1180 sbr->kx[0] = sbr->kx[1];
1181 sbr->m[0] = sbr->m[1];
1182 sbr->kx_and_m_pushed = 1;
1183
1184 num_sbr_bits++;
1185 if (get_bits1(gb)) // bs_header_flag
1186 num_sbr_bits += read_sbr_header(sbr, gb, 0);
1187
1188 if (sbr->reset)
1189 sbr_reset(ac, sbr);
1190
1191 if (sbr->start)
1192 num_sbr_bits += read_sbr_data(ac, sbr, gb, id_aac, numTimeSlots);
1193
1194 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1195 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1196
1197 if (bytes_read > cnt) {
1198 av_log(ac->avctx, AV_LOG_ERROR,
1199 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1200 sbr_turnoff(sbr);
1201 }
1202 return cnt;
1203}
1204
1205#if !USE_FIXED
1208{
1209 sbr->inter_tes = ue->sbr.bs_intertes;
1210
1211 sbr->spectrum_params.bs_start_freq = ue->sbr.dflt.start_freq;
1212 sbr->spectrum_params.bs_stop_freq = ue->sbr.dflt.stop_freq;
1213
1214 sbr->spectrum_params.bs_freq_scale = ue->sbr.dflt.freq_scale;
1215 sbr->spectrum_params.bs_alter_scale = ue->sbr.dflt.alter_scale;
1216 sbr->spectrum_params.bs_noise_bands = ue->sbr.dflt.noise_bands;
1217
1218 sbr->bs_limiter_bands = ue->sbr.dflt.limiter_bands;
1219 sbr->bs_limiter_gains = ue->sbr.dflt.limiter_gains;
1220 sbr->bs_interpol_freq = ue->sbr.dflt.interpol_freq;
1221 sbr->bs_smoothing_mode = ue->sbr.dflt.smoothing_mode;
1222}
1223
1226{
1227 SpectralBandReplication *sbr = get_sbr(che);
1228 sbr_turnoff(sbr);
1229 return 0;
1230}
1231
1234 int sbr_ch, int indep_flag)
1235{
1236 int ret;
1237 int info_present = 1;
1238 int header_present = 1;
1239
1240 sbr->reset = 0;
1241 sbr->usac = 1;
1242
1243 sbr->sample_rate = ac->oc[1].m4ac.ext_sample_rate;
1244 sbr->id_aac = sbr_ch == 2 ? TYPE_CPE : TYPE_SCE;
1245
1246 if (!indep_flag) {
1247 info_present = get_bits1(gb);
1248 if (info_present)
1249 header_present = get_bits1(gb);
1250 else
1251 header_present = 0;
1252 }
1253
1254 if (info_present) {
1255 /* SbrInfo() */
1256 sbr->bs_amp_res_header = get_bits1(gb);
1259 /* if (bs_pvc) ... */
1260 }
1261
1262 if (header_present) {
1263 if (get_bits1(gb)) {
1264 int old_bs_limiter_bands = sbr->bs_limiter_bands;
1265 SpectrumParameters old_spectrum_params;
1266 memcpy(&old_spectrum_params, &sbr->spectrum_params,
1267 sizeof(SpectrumParameters));
1268
1270 // Check if spectrum parameters changed
1271 if (memcmp(&old_spectrum_params, &sbr->spectrum_params,
1272 sizeof(SpectrumParameters)))
1273 sbr->reset = 1;
1274
1275 if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
1277 } else {
1278 read_sbr_header(sbr, gb, 1);
1279 }
1280
1281 sbr->start = 1;
1282 }
1283
1284 //Save some state from the previous frame.
1285 sbr->kx[0] = sbr->kx[1];
1286 sbr->m[0] = sbr->m[1];
1287 sbr->kx_and_m_pushed = 1;
1288
1289 if (sbr->reset)
1290 sbr_reset(ac, sbr);
1291
1292 sbr->ready_for_dequant = 1;
1293
1294 if (sbr_ch == 1) { /* sbr_single_channel_element */
1295 /* if (harmonicSBR) ... */
1296
1297 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0], 16))
1298 return -1;
1299
1300 read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
1301 read_sbr_invf(sbr, gb, &sbr->data[0]);
1302
1303 if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1304 return ret;
1305
1306 if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1307 return ret;
1308
1309 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
1310 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
1311 } else if (get_bits1(gb)) { /* bs_coupling == 1 */
1312 sbr->bs_coupling = 1;
1313
1314 /* if (harmonicSBR) ... */
1315
1316 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0], 16))
1317 return -1;
1318 copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
1319
1320 read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
1321 read_sbr_dtdf(sbr, gb, &sbr->data[1], indep_flag);
1322
1323 read_sbr_invf(sbr, gb, &sbr->data[0]);
1324 memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0],
1325 sizeof(sbr->data[1].bs_invf_mode[0]));
1326 memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0],
1327 sizeof(sbr->data[1].bs_invf_mode[0]));
1328
1329 if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1330 return ret;
1331 if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1332 return ret;
1333
1334 if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1335 return ret;
1336 if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1337 return ret;
1338
1339 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
1340 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
1341 if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
1342 get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
1343 } else { /* bs_coupling == 0 */
1344 sbr->bs_coupling = 0;
1345
1346 /* if (harmonicSBR) ... */
1347
1348 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0], 16))
1349 return -1;
1350 if (read_sbr_grid(ac, sbr, gb, &sbr->data[1], 16))
1351 return -1;
1352
1353 read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
1354 read_sbr_dtdf(sbr, gb, &sbr->data[1], indep_flag);
1355
1356 read_sbr_invf(sbr, gb, &sbr->data[0]);
1357 read_sbr_invf(sbr, gb, &sbr->data[1]);
1358
1359 if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1360 return ret;
1361 if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1362 return ret;
1363
1364 if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1365 return ret;
1366 if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1367 return ret;
1368
1369 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
1370 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
1371 if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
1372 get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
1373 }
1374
1375 return 0;
1376}
1377
1380 int sbr_ch, int indep_flag)
1381{
1382 SpectralBandReplication *sbr = get_sbr(che);
1383 int ret = read_usac_sbr_data(ac, sbr, ue, gb, sbr_ch, indep_flag);
1384
1385 if (ret < 0)
1386 sbr_turnoff(sbr);
1387
1388 return ret;
1389}
1390#endif
1391
1392/**
1393 * Analysis QMF Bank (14496-3 sp04 p206)
1394 *
1395 * @param x pointer to the beginning of the first sample window
1396 * @param W array of complex-valued samples split into subbands
1397 */
1398#ifndef sbr_qmf_analysis
1399#if USE_FIXED
1400static void sbr_qmf_analysis(AVFixedDSPContext *dsp, AVTXContext *mdct,
1401 av_tx_fn mdct_fn,
1402#else
1404 av_tx_fn mdct_fn,
1405#endif /* USE_FIXED */
1406 SBRDSPContext *sbrdsp, const INTFLOAT *in, INTFLOAT *x,
1407 INTFLOAT z[320], INTFLOAT W[2][32][32][2], int buf_idx,
1408 int numTimeSlots)
1409{
1410 int i;
1411#if USE_FIXED
1412 int j;
1413#endif
1414 int nb = numTimeSlots * 64;
1415 memcpy(x , x+nb, (320-32)*sizeof(x[0]));
1416 memcpy(x+288, in, nb*sizeof(x[0]));
1417 for (i = 0; i < numTimeSlots*2; i++) { // RATE*numTimeSlots = 2* 16 or 15
1418 dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
1419 sbrdsp->sum64x5(z);
1420 sbrdsp->qmf_pre_shuffle(z);
1421#if USE_FIXED
1422 for (j = 64; j < 128; j++) {
1423 if (z[j] > 1<<24) {
1425 "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1426 z[j], 1<<24);
1427 z[j] = 1<<24;
1428 } else if (z[j] < -(1<<24)) {
1430 "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1431 z[j], -(1<<24));
1432 z[j] = -(1<<24);
1433 }
1434 }
1435#endif
1436 mdct_fn(mdct, z, z + 64, sizeof(INTFLOAT));
1437 sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
1438 x += 32;
1439 }
1440}
1441#endif
1442
1443/**
1444 * Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank
1445 * (14496-3 sp04 p206)
1446 */
1447#ifndef sbr_qmf_synthesis
1448static void sbr_qmf_synthesis(AVTXContext *mdct, av_tx_fn mdct_fn,
1449#if USE_FIXED
1450 SBRDSPContext *sbrdsp, AVFixedDSPContext *dsp,
1451#else
1452 SBRDSPContext *sbrdsp, AVFloatDSPContext *dsp,
1453#endif /* USE_FIXED */
1454 INTFLOAT *out, INTFLOAT X[2][38][64],
1455 INTFLOAT mdct_buf[2][64],
1456 INTFLOAT *v0, int *v_off, int numTimeSlots,
1457 const unsigned int div)
1458{
1459 int i, n;
1460 const INTFLOAT *sbr_qmf_window = div ? sbr_qmf_window_ds : sbr_qmf_window_us;
1461 const int step = 128 >> div;
1462 INTFLOAT *v;
1463 for (i = 0; i < numTimeSlots*2; i++) {
1464 if (*v_off < step) {
1465 int saved_samples = (1280 - 128) >> div;
1466 memcpy(&v0[SBR_SYNTHESIS_BUF_SIZE - saved_samples], v0, saved_samples * sizeof(INTFLOAT));
1467 *v_off = SBR_SYNTHESIS_BUF_SIZE - saved_samples - step;
1468 } else {
1469 *v_off -= step;
1470 }
1471 v = v0 + *v_off;
1472 if (div) {
1473 for (n = 0; n < 32; n++) {
1474 X[0][i][ n] = -X[0][i][n];
1475 X[0][i][32+n] = X[1][i][31-n];
1476 }
1477 mdct_fn(mdct, mdct_buf[0], X[0][i], sizeof(INTFLOAT));
1478 sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1479 } else {
1480 sbrdsp->neg_odd_64(X[1][i]);
1481 mdct_fn(mdct, mdct_buf[0], X[0][i], sizeof(INTFLOAT));
1482 mdct_fn(mdct, mdct_buf[1], X[1][i], sizeof(INTFLOAT));
1483 sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1484 }
1485 dsp->vector_fmul (out, v , sbr_qmf_window , 64 >> div);
1486 dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div);
1487 dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div);
1488 dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div);
1489 dsp->vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div);
1490 dsp->vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div);
1491 dsp->vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div);
1492 dsp->vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div);
1493 dsp->vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div);
1494 dsp->vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div);
1495 out += 64 >> div;
1496 }
1497}
1498#endif
1499
1500/// Generate the subband filtered lowband
1502 INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2],
1503 int buf_idx, int numTimeSlots)
1504{
1505 int i, k;
1506 const int t_HFGen = 8;
1507 const int i_f = numTimeSlots*2;
1508 memset(X_low, 0, 32*sizeof(*X_low));
1509 for (k = 0; k < sbr->kx[1]; k++) {
1510 for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1511 X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0];
1512 X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1];
1513 }
1514 }
1515 buf_idx = 1-buf_idx;
1516 for (k = 0; k < sbr->kx[0]; k++) {
1517 for (i = 0; i < t_HFGen; i++) {
1518 X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
1519 X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
1520 }
1521 }
1522 return 0;
1523}
1524
1525/// High Frequency Generator (14496-3 sp04 p215)
1527 INTFLOAT X_high[64][40][2], const INTFLOAT X_low[32][40][2],
1528 const INTFLOAT (*alpha0)[2], const INTFLOAT (*alpha1)[2],
1529 const INTFLOAT bw_array[5], const uint8_t *t_env,
1530 int bs_num_env)
1531{
1532 int j, x;
1533 int g = 0;
1534 int k = sbr->kx[1];
1535 for (j = 0; j < sbr->num_patches; j++) {
1536 for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
1537 const int p = sbr->patch_start_subband[j] + x;
1538 while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
1539 g++;
1540 g--;
1541
1542 if (g < 0) {
1544 "ERROR : no subband found for frequency %d\n", k);
1545 return -1;
1546 }
1547
1548 sbr->dsp.hf_gen(X_high[k] + ENVELOPE_ADJUSTMENT_OFFSET,
1549 X_low[p] + ENVELOPE_ADJUSTMENT_OFFSET,
1550 alpha0[p], alpha1[p], bw_array[g],
1551 2 * t_env[0], 2 * t_env[bs_num_env]);
1552 }
1553 }
1554 if (k < sbr->m[1] + sbr->kx[1])
1555 memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
1556
1557 return 0;
1558}
1559
1560/// Generate the subband filtered lowband
1561static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64],
1562 const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2],
1563 const INTFLOAT X_low[32][40][2], int ch, int numTimeSlots)
1564{
1565 int k, i;
1566 const int i_f = numTimeSlots*2;
1567 const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
1568 memset(X, 0, 2*sizeof(*X));
1569 for (k = 0; k < sbr->kx[0]; k++) {
1570 for (i = 0; i < i_Temp; i++) {
1571 X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1572 X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1573 }
1574 }
1575 for (; k < sbr->kx[0] + sbr->m[0]; k++) {
1576 for (i = 0; i < i_Temp; i++) {
1577 X[0][i][k] = Y0[i + i_f][k][0];
1578 X[1][i][k] = Y0[i + i_f][k][1];
1579 }
1580 }
1581
1582 for (k = 0; k < sbr->kx[1]; k++) {
1583 for (i = i_Temp; i < 38; i++) {
1584 X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1585 X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1586 }
1587 }
1588 for (; k < sbr->kx[1] + sbr->m[1]; k++) {
1589 for (i = i_Temp; i < i_f; i++) {
1590 X[0][i][k] = Y1[i][k][0];
1591 X[1][i][k] = Y1[i][k][1];
1592 }
1593 }
1594 return 0;
1595}
1596
1597/** High Frequency Adjustment (14496-3 sp04 p217) and Mapping
1598 * (14496-3 sp04 p217)
1599 */
1601 SBRData *ch_data, int e_a[2])
1602{
1603 int e, i, m;
1604
1605 memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
1606 for (e = 0; e < ch_data->bs_num_env; e++) {
1607 const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
1608 uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1609 int k;
1610
1611 if (sbr->kx[1] != table[0]) {
1612 av_log(ac->avctx, AV_LOG_ERROR, "kx != f_table{high,low}[0]. "
1613 "Derived frequency tables were not regenerated.\n");
1614 sbr_turnoff(sbr);
1615 return AVERROR_BUG;
1616 }
1617 for (i = 0; i < ilim; i++)
1618 for (m = table[i]; m < table[i + 1]; m++)
1619 sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
1620
1621 // ch_data->bs_num_noise > 1 => 2 noise floors
1622 k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
1623 for (i = 0; i < sbr->n_q; i++)
1624 for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1625 sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
1626
1627 for (i = 0; i < sbr->n[1]; i++) {
1628 if (ch_data->bs_add_harmonic_flag) {
1629 const unsigned int m_midpoint =
1630 (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
1631
1632 ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
1633 (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
1634 }
1635 }
1636
1637 for (i = 0; i < ilim; i++) {
1638 int additional_sinusoid_present = 0;
1639 for (m = table[i]; m < table[i + 1]; m++) {
1640 if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
1641 additional_sinusoid_present = 1;
1642 break;
1643 }
1644 }
1645 memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
1646 (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
1647 }
1648 }
1649
1650 memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
1651 return 0;
1652}
1653
1654/// Estimation of current envelope (14496-3 sp04 p218)
1655static void sbr_env_estimate(AAC_FLOAT (*e_curr)[48], INTFLOAT X_high[64][40][2],
1656 SpectralBandReplication *sbr, SBRData *ch_data)
1657{
1658 int e, m;
1659 int kx1 = sbr->kx[1];
1660
1661 if (sbr->bs_interpol_freq) {
1662 for (e = 0; e < ch_data->bs_num_env; e++) {
1663#if USE_FIXED
1664 const SoftFloat recip_env_size = av_int2sf(0x20000000 / (ch_data->t_env[e + 1] - ch_data->t_env[e]), 30);
1665#else
1666 const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1667#endif /* USE_FIXED */
1668 int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1669 int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1670
1671 if (ilb >= 40)
1672 return;
1673
1674 for (m = 0; m < sbr->m[1]; m++) {
1675 AAC_FLOAT sum = sbr->dsp.sum_square(X_high[m+kx1] + ilb, iub - ilb);
1676#if USE_FIXED
1677 e_curr[e][m] = av_mul_sf(sum, recip_env_size);
1678#else
1679 e_curr[e][m] = sum * recip_env_size;
1680#endif /* USE_FIXED */
1681 }
1682 }
1683 } else {
1684 int k, p;
1685
1686 for (e = 0; e < ch_data->bs_num_env; e++) {
1687 const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1688 int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1689 int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1690 const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1691
1692 if (ilb >= 40)
1693 return;
1694
1695 for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
1696#if USE_FIXED
1697 SoftFloat sum = FLOAT_0;
1698 const SoftFloat den = av_int2sf(0x20000000 / (env_size * (table[p + 1] - table[p])), 29);
1699 for (k = table[p]; k < table[p + 1]; k++) {
1700 sum = av_add_sf(sum, sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb));
1701 }
1702 sum = av_mul_sf(sum, den);
1703#else
1704 float sum = 0.0f;
1705 const int den = env_size * (table[p + 1] - table[p]);
1706
1707 for (k = table[p]; k < table[p + 1]; k++) {
1708 sum += sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb);
1709 }
1710 sum /= den;
1711#endif /* USE_FIXED */
1712 for (k = table[p]; k < table[p + 1]; k++) {
1713 e_curr[e][k - kx1] = sum;
1714 }
1715 }
1716 }
1717 }
1718}
1719
1721 int id_aac, int fl960, void *L_, void *R_)
1722{
1723 INTFLOAT *L = L_, *R = R_;
1724 SpectralBandReplication *sbr = get_sbr(che);
1725 int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1726 int ch;
1727 int nch = (id_aac == TYPE_CPE) ? 2 : 1;
1728 int err;
1729 int numTimeSlots = fl960 ? 15 : 16;
1730
1731 if (id_aac != sbr->id_aac) {
1732 av_log(ac->avctx, id_aac == TYPE_LFE ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1733 "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
1734 sbr_turnoff(sbr);
1735 }
1736
1737 if (sbr->start && !sbr->ready_for_dequant) {
1738 av_log(ac->avctx, AV_LOG_ERROR,
1739 "No quantized data read for sbr_dequant.\n");
1740 sbr_turnoff(sbr);
1741 }
1742
1743 if (!sbr->kx_and_m_pushed) {
1744 sbr->kx[0] = sbr->kx[1];
1745 sbr->m[0] = sbr->m[1];
1746 } else {
1747 sbr->kx_and_m_pushed = 0;
1748 }
1749
1750 if (sbr->start) {
1751 sbr_dequant(sbr, id_aac);
1752 sbr->ready_for_dequant = 0;
1753 }
1754 for (ch = 0; ch < nch; ch++) {
1755 /* decode channel */
1756 sbr_qmf_analysis(ac->fdsp, sbr->mdct_ana, sbr->mdct_ana_fn, &sbr->dsp,
1757 ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
1759 sbr->data[ch].W, sbr->data[ch].Ypos, numTimeSlots);
1760 sbr->c.sbr_lf_gen(sbr, sbr->X_low,
1761 (const INTFLOAT (*)[32][32][2]) sbr->data[ch].W,
1762 sbr->data[ch].Ypos, numTimeSlots);
1763 sbr->data[ch].Ypos ^= 1;
1764 if (sbr->start) {
1765 sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
1766 (const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]);
1767 sbr_chirp(sbr, &sbr->data[ch]);
1768 av_assert0(sbr->data[ch].bs_num_env > 0);
1769 sbr_hf_gen(ac, sbr, sbr->X_high,
1770 (const INTFLOAT (*)[40][2]) sbr->X_low,
1771 (const INTFLOAT (*)[2]) sbr->alpha0,
1772 (const INTFLOAT (*)[2]) sbr->alpha1,
1773 sbr->data[ch].bw_array, sbr->data[ch].t_env,
1774 sbr->data[ch].bs_num_env);
1775
1776 // hf_adj
1777 err = sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1778 if (!err) {
1779 sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
1780 sbr_gain_calc(sbr, &sbr->data[ch], sbr->data[ch].e_a);
1781 sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
1782 (const INTFLOAT (*)[40][2]) sbr->X_high,
1783 sbr, &sbr->data[ch],
1784 sbr->data[ch].e_a);
1785 }
1786 }
1787
1788 /* synthesis */
1789 sbr->c.sbr_x_gen(sbr, sbr->X[ch],
1790 (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos],
1791 (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[ sbr->data[ch].Ypos],
1792 (const INTFLOAT (*)[40][2]) sbr->X_low, ch, numTimeSlots);
1793 }
1794
1795 if (ac->oc[1].m4ac.ps == 1) {
1796 if (sbr->ps.common.start) {
1797 AAC_RENAME(ff_ps_apply)(&sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
1798 } else {
1799 memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));
1800 }
1801 nch = 2;
1802 }
1803
1804 sbr_qmf_synthesis(sbr->mdct, sbr->mdct_fn, &sbr->dsp, ac->fdsp,
1805 L, sbr->X[0], sbr->qmf_filter_scratch,
1808 numTimeSlots, downsampled);
1809 if (nch == 2)
1810 sbr_qmf_synthesis(sbr->mdct, sbr->mdct_fn, &sbr->dsp, ac->fdsp,
1811 R, sbr->X[1], sbr->qmf_filter_scratch,
1814 numTimeSlots, downsampled);
1815}
1816
1818{
1819 c->sbr_lf_gen = sbr_lf_gen;
1820 c->sbr_hf_assemble = sbr_hf_assemble;
1821 c->sbr_x_gen = sbr_x_gen;
1822 c->sbr_hf_inverse_filter = sbr_hf_inverse_filter;
1823}
@ TYPE_CCE
Definition aac.h:46
@ TYPE_CPE
Definition aac.h:45
@ TYPE_SCE
Definition aac.h:44
@ TYPE_LFE
Definition aac.h:47
#define MAX_PREDICTORS
Definition aac.h:89
#define AAC_RENAME(x)
Definition aac_defines.h:99
float AAC_FLOAT
#define Q23(x)
AAC decoder definitions and structures.
const VLCElem * ff_aac_sbr_vlc[10]
Definition aacdec_tab.c:262
AAC decoder data.
av_cold void AAC_RENAME ff_ps_init(void)
Definition aacps.c:740
int AAC_RENAME ff_ps_apply(PSContext *ps, INTFLOAT L[2][38][64], INTFLOAT R[2][38][64], int top)
Definition aacps.c:719
int ff_ps_read_data(void *logctx, GetBitContext *gb, PSCommonContext *ps, int bits_left)
static void AAC_RENAME ff_ps_ctx_init(PSContext *ps)
Definition aacps.h:97
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)
Definition aacsbr.c:289
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...
Definition aacsbr.c:153
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 ...
Definition aacsbr.c:232
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition aacsbr.c:67
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition aacsbr.c:86
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition aacsbr.c:208
FF_VISIBILITY_PUSH_HIDDEN void ff_aac_sbr_init(void)
Initialize SBR.
int ff_aac_sbr_decode_extension(AACDecContext *ac, ChannelElement *che, GetBitContext *gb, int crc, int cnt, int id_aac, int fl960)
Decode one SBR element.
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition aacsbr.h:37
@ EXTENSION_ID_PS
Definition aacsbr.h:67
void ff_aac_sbr_ctx_close(ChannelElement *che)
Close the SBR context implicitly contained in a ChannelElement.
@ VARVAR
Definition aacsbr.h:63
@ VARFIX
Definition aacsbr.h:62
@ FIXVAR
Definition aacsbr.h:61
@ FIXFIX
Definition aacsbr.h:60
@ F_HUFFMAN_ENV_1_5DB
Definition aacsbr.h:45
@ F_HUFFMAN_ENV_BAL_3_0DB
Definition aacsbr.h:51
@ T_HUFFMAN_NOISE_3_0DB
Definition aacsbr.h:52
@ T_HUFFMAN_ENV_BAL_1_5DB
Definition aacsbr.h:46
@ F_HUFFMAN_ENV_3_0DB
Definition aacsbr.h:49
@ T_HUFFMAN_NOISE_BAL_3_0DB
Definition aacsbr.h:53
@ T_HUFFMAN_ENV_1_5DB
Definition aacsbr.h:44
@ T_HUFFMAN_ENV_3_0DB
Definition aacsbr.h:48
@ F_HUFFMAN_ENV_BAL_1_5DB
Definition aacsbr.h:47
@ T_HUFFMAN_ENV_BAL_3_0DB
Definition aacsbr.h:50
void ff_aac_sbr_apply(AACDecContext *ac, ChannelElement *che, int id_aac, int fl960, void *L, void *R)
Apply one SBR element to one AAC element.
int 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.
void ff_aac_sbr_ctx_reset(AACDecContext *ac, ChannelElement *che)
Reset the SBR context contained in a ChannelElement, discarding all inter-frame state while keeping t...
static int fixed_log(int x)
static const int CONST_076923
static const int CONST_RECIP_LN2
static unsigned int read_sbr_data(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int id_aac, int numTimeSlots)
static int sbr_make_f_derived(AACDecContext *ac, SpectralBandReplication *sbr)
Derived Frequency Band Tables (14496-3 sp04 p197)
static int read_sbr_grid(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int numTimeSlots)
static int read_usac_sbr_data(AACDecContext *ac, SpectralBandReplication *sbr, AACUsacElemConfig *ue, GetBitContext *gb, int sbr_ch, int indep_flag)
static SpectralBandReplication * get_sbr(ChannelElement *ch)
static int read_sbr_channel_pair_element(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int numTimeSlots)
static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb, int is_usac)
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, int numTimeSlots)
Analysis QMF Bank (14496-3 sp04 p206)
static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec, int elements)
static const int8_t ceil_log2[]
ceil(log2(index+1))
static int in_table_int16(const int16_t *table, int last_el, int16_t needle)
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, int numTimeSlots, const unsigned int div)
Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank (14496-3 sp04 p206)
static int array_min_int16(const int16_t *array, int nel)
static void aacsbr_func_ptr_init(AACSBRContext *c)
static void sbr_turnoff(SpectralBandReplication *sbr)
Places SBR in pure upsampling mode.
static void copy_sbr_grid(SBRData *dst, const SBRData *src)
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...
static void sbr_reset(AACDecContext *ac, SpectralBandReplication *sbr)
static int sbr_hf_calc_npatches(AACDecContext *ac, SpectralBandReplication *sbr)
High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
static int sbr_make_f_master(AACDecContext *ac, SpectralBandReplication *sbr, SpectrumParameters *spectrum)
Master Frequency Band Table (14496-3 sp04 p194)
static int read_sbr_noise(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
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)
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, int numTimeSlots)
Generate the subband filtered lowband.
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)
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 read_sbr_extension(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int bs_extension_id, int *num_bits_left)
static int sbr_lf_gen(SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx, int numTimeSlots)
Generate the subband filtered lowband.
static int qsort_comparison_function_int16(const void *a, const void *b)
static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
static void copy_usac_default_header(SpectralBandReplication *sbr, AACUsacElemConfig *ue)
static int read_sbr_envelope(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
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)
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_make_f_tablelim(SpectralBandReplication *sbr)
Limiter Frequency Band Table (14496-3 sp04 p198)
static int read_sbr_single_channel_element(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int numTimeSlots)
static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read inverse filtering data.
static const int8_t sbr_offset[6][16]
Definition aacsbrdata.h:35
static const INTFLOAT sbr_qmf_window_ds[320]
window coefficients for analysis/synthesis QMF banks
Definition aacsbrdata.h:45
static const INTFLOAT sbr_qmf_window_us[640]
Definition aacsbrdata.h:210
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:97
#define log2f(x)
Definition math.h:27
static FILE * out
#define L(x)
Definition vpx_arith.h:36
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
Libavcodec external API header.
#define ue(name, range_min, range_max)
Definition cbs_h264.c:61
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
#define min(a, b)
#define INTFLOAT
#define AV_PROFILE_AAC_HE_V2
Definition defs.h:73
#define X
Definition f_ebur128.c:158
static const uint8_t bits[8]
Definition fastaudio.c:100
int ret
Definition ffplay.c:391
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition get_bits.h:645
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition get_bits.h:280
static unsigned int get_bits1(GetBitContext *s)
Definition get_bits.h:391
static void skip_bits(GetBitContext *s, int n)
Definition get_bits.h:383
static int get_bits_count(const GetBitContext *s)
Definition get_bits.h:254
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition get_bits.h:337
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition get_bits.h:373
#define fail
Definition test.h:479
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition error.h:52
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
#define AVERROR(e)
Definition error.h:45
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_VERBOSE
Detailed information.
Definition log.h:226
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
int a
static av_always_inline void scale(vec_s32 res[4], vec_s16 res_packed[2], const int shift)
#define R
Definition huffyuv.h:44
#define b
Definition input.c:43
#define W(a, i, v)
Definition jpegls.h:119
#define USE_FIXED
Definition aacdec.c:34
#define av_always_inline
Definition attributes.h:72
#define av_cold
Definition attributes.h:117
#define lrintf(x)
Definition libm_mips.h:74
#define FFMIN(a, b)
Definition macros.h:49
#define FFMAX(a, b)
Definition macros.h:47
Memory handling functions.
static const uint16_t table[]
Definition prosumer.c:203
#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...
Definition qsort.h:33
#define SBR_SYNTHESIS_BUF_SIZE
Definition sbr.h:58
void AAC_RENAME ff_sbrdsp_init(SBRDSPContext *s)
static const ElemCat * elements[ELEMENT_COUNT]
Definition signature.h:565
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
Definition softfloat.h:162
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
Definition softfloat.h:102
static const SoftFloat FLOAT_0
0.0
Definition softfloat.h:39
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
Definition softfloat.h:185
main AAC decoding context
Definition aacdec.h:501
struct AVCodecContext * avctx
Definition aacdec.h:503
int warned_he_aac_mono
Definition aacdec.h:591
OutputConfiguration oc[2]
Definition aacdec.h:587
aacsbr functions pointers
Definition sbr.h:124
int(* sbr_lf_gen)(SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx, int numTimeSlots)
Definition sbr.h:125
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, int numTimeSlots)
Definition sbr.h:132
void(* sbr_hf_inverse_filter)(SBRDSPContext *dsp, INTFLOAT(*alpha0)[2], INTFLOAT(*alpha1)[2], const INTFLOAT X_low[32][40][2], int k0)
Definition sbr.h:135
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])
Definition sbr.h:128
main external API structure.
Definition avcodec.h:443
int profile
profile
Definition avcodec.h:1646
void(* vector_fmul_add)(int *dst, const int *src0, const int *src1, const int *src2, int len)
Calculate the entry wise product of two vectors of integers, add a third vector of integers and store...
Definition fixed_dsp.h:131
void(* vector_fmul)(int *dst, const int *src0, const int *src1, int len)
Fixed-point multiplication that calculates the entry wise product of two vectors of integers and stor...
Definition fixed_dsp.h:112
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...
Definition float_dsp.h:154
channel element - generic struct for SCE/CPE/CCE/LFE
Definition aacdec.h:296
SingleChannelElement ch[2]
Definition aacdec.h:302
SpectralBandReplication sbr
PredictorState predictor_state[2][MAX_PREDICTORS]
ChannelElement ch
int ps
-1 implicit, 1 presence
Definition mpeg4audio.h:40
MPEG4AudioConfig m4ac
Definition aacdec.h:420
PSCommonContext common
Definition aacps.h:72
Predictor State.
AAC_FLOAT(* sum_square)(INTFLOAT(*x)[2], int n)
Definition sbrdsp.h:29
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)
Definition sbrdsp.h:36
Spectral Band Replication per channel data.
Definition sbr.h:63
AAC_FLOAT env_facs[9][48]
Definition sbr.h:101
INTFLOAT bw_array[5]
Chirp factors.
Definition sbr.h:90
uint8_t t_q[3]
Noise time borders.
Definition sbr.h:110
AAC_SIGNE bs_num_env
Definition sbr.h:70
uint8_t s_indexmapped[9][48]
Definition sbr.h:98
unsigned bs_amp_res
Definition sbr.h:77
uint8_t temp_shape_mode[6]
Definition sbr.h:115
unsigned bs_add_harmonic_flag
Definition sbr.h:69
uint8_t noise_facs_q[3][5]
Noise scalefactors.
Definition sbr.h:103
uint8_t bs_df_env[9]
Definition sbr.h:73
AAC_SIGNE bs_num_noise
Definition sbr.h:72
int e_a[2]
l_APrev and l_A
Definition sbr.h:88
unsigned f_indexnoise
Definition sbr.h:111
int Ypos
QMF output of the HF adjustor.
Definition sbr.h:94
unsigned bs_frame_class
Definition sbr.h:68
INTFLOAT Y[2][38][64][2]
Definition sbr.h:95
uint8_t bs_df_noise[2]
Definition sbr.h:74
INTFLOAT analysis_filterbank_samples[1312]
Definition sbr.h:85
uint8_t bs_freq_res[9]
Definition sbr.h:71
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
Definition sbr.h:108
uint8_t env_facs_q[9][48]
Envelope scalefactors.
Definition sbr.h:100
uint8_t bs_invf_mode[2][5]
Definition sbr.h:75
uint8_t temp_shape[6]
Definition sbr.h:114
AAC_FLOAT noise_facs[3][5]
Definition sbr.h:104
int synthesis_filterbank_samples_offset
Definition sbr.h:86
uint8_t bs_add_harmonic[48]
Definition sbr.h:76
INTFLOAT synthesis_filterbank_samples[SBR_SYNTHESIS_BUF_SIZE]
Definition sbr.h:84
uint8_t t_env[9]
Envelope time borders.
Definition sbr.h:106
INTFLOAT W[2][32][32][2]
QMF values of the original signal.
Definition sbr.h:92
Spectral Band Replication.
Definition sbr.h:143
uint16_t f_tablehigh[49]
Frequency borders for high resolution SBR.
Definition sbr.h:186
INTFLOAT alpha1[64][2]
First coefficient used to filter the subband signals.
Definition sbr.h:203
uint8_t patch_num_subbands[6]
Definition sbr.h:192
SpectrumParameters spectrum_params
Definition sbr.h:151
unsigned bs_interpol_freq
Definition sbr.h:160
av_tx_fn mdct_ana_fn
Definition sbr.h:219
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition sbr.h:169
unsigned bs_limiter_bands
Definition sbr.h:158
AACSBRContext c
Definition sbr.h:223
unsigned bs_coupling
Definition sbr.h:163
AVTXContext * mdct
Definition sbr.h:220
uint16_t f_tablenoise[6]
Frequency borders for noise floors.
Definition sbr.h:188
unsigned bs_smoothing_mode
Definition sbr.h:161
unsigned bs_limiter_gains
Definition sbr.h:159
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition sbr.h:167
uint16_t f_tablelow[25]
Frequency borders for low resolution SBR.
Definition sbr.h:184
INTFLOAT X[2][2][38][64]
QMF values of the reconstructed signal.
Definition sbr.h:199
INTFLOAT alpha0[64][2]
Zeroth coefficient used to filter the subband signals.
Definition sbr.h:201
uint8_t s_mapped[8][48]
Sinusoidal presence, remapped.
Definition sbr.h:209
AAC_FLOAT e_origmapped[8][48]
Dequantized envelope scalefactors, remapped.
Definition sbr.h:205
AAC_SIGNE n_q
Number of noise floor bands.
Definition sbr.h:178
AAC_SIGNE k[5]
k0, k1, k2
Definition sbr.h:164
AAC_SIGNE n_lim
Number of limiter bands.
Definition sbr.h:180
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition sbr.h:190
INTFLOAT X_low[32][40][2]
QMF low frequency input to the HF generator.
Definition sbr.h:195
INTFLOAT X_high[64][40][2]
QMF output of the HF generator.
Definition sbr.h:197
AVTXContext * mdct_ana
Definition sbr.h:218
AAC_SIGNE n_master
The number of frequency bands in f_master.
Definition sbr.h:172
AAC_SIGNE num_patches
Definition sbr.h:191
unsigned kx_and_m_pushed
Definition sbr.h:170
uint8_t patch_start_subband[6]
Definition sbr.h:193
AAC_FLOAT q_mapped[8][48]
Dequantized noise scalefactors, remapped.
Definition sbr.h:207
uint16_t f_master[49]
The master QMF frequency grouping.
Definition sbr.h:182
AAC_FLOAT e_curr[8][48]
Estimated envelope.
Definition sbr.h:211
SBRData data[2]
Definition sbr.h:173
INTFLOAT qmf_filter_scratch[5][64]
Definition sbr.h:217
SBRDSPContext dsp
Definition sbr.h:222
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
Definition sbr.h:176
Spectral Band Replication header - spectrum parameters that invoke a reset if they differ from the pr...
Definition sbr.h:43
uint8_t bs_noise_bands
Definition sbr.h:54
uint8_t bs_stop_freq
Definition sbr.h:45
uint8_t bs_alter_scale
Definition sbr.h:53
uint8_t bs_start_freq
Definition sbr.h:44
uint8_t bs_xover_band
Definition sbr.h:46
uint8_t bs_freq_scale
Definition sbr.h:52
Definition vlc.h:32
#define av_free(p)
#define av_mallocz(s)
#define avpriv_request_sample(...)
#define av_log(a,...)
static uint8_t tmp[40]
Definition aes_ctr.c:52
#define src
Definition vp8dsp.c:248
static int array[MAX_W *MAX_W]
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition tx.c:295
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...
Definition tx.c:903
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respectively.
Definition tx.h:68
@ AV_TX_INT32_MDCT
Definition tx.h:70
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition tx.h:151
const char * g
Definition vf_curves.c:128
else temp
Definition vf_mcdeint.c:275
float delta
static double c[64]