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>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * AAC Spectral Band Replication decoding functions
26 * @author Robert Swain ( rob opendot cl )
32 #include "aacsbrdata.h"
33 #include "aacsbr_tablegen.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/libm.h"
39 #include "libavutil/avassert.h"
45 #define ENVELOPE_ADJUSTMENT_OFFSET 2
46 #define NOISE_FLOOR_OFFSET 6.0f
49 #include "mips/aacsbr_mips.h"
50 #endif /* ARCH_MIPS */
58 T_HUFFMAN_ENV_BAL_1_5DB
,
59 F_HUFFMAN_ENV_BAL_1_5DB
,
62 T_HUFFMAN_ENV_BAL_3_0DB
,
63 F_HUFFMAN_ENV_BAL_3_0DB
,
64 T_HUFFMAN_NOISE_3_0DB
,
65 T_HUFFMAN_NOISE_BAL_3_0DB
,
69 * bs_frame_class - frame class of current SBR frame (14496-3 sp04 p98)
82 static VLC vlc_sbr
[10];
83 static const int8_t vlc_sbr_lav
[10] =
84 { 60, 60, 24, 24, 31, 31, 12, 12, 31, 12 };
86 #define SBR_INIT_VLC_STATIC(num, size) \
87 INIT_VLC_STATIC(&vlc_sbr[num], 9, sbr_tmp[num].table_size / sbr_tmp[num].elem_size, \
88 sbr_tmp[num].sbr_bits , 1, 1, \
89 sbr_tmp[num].sbr_codes, sbr_tmp[num].elem_size, sbr_tmp[num].elem_size, \
92 #define SBR_VLC_ROW(name) \
93 { name ## _codes, name ## _bits, sizeof(name ## _codes), sizeof(name ## _codes[0]) }
95 static void aacsbr_func_ptr_init(AACSBRContext
*c
);
97 av_cold
void ff_aac_sbr_init(void)
100 const void *sbr_codes
, *sbr_bits
;
101 const unsigned int table_size
, elem_size
;
103 SBR_VLC_ROW(t_huffman_env_1_5dB
),
104 SBR_VLC_ROW(f_huffman_env_1_5dB
),
105 SBR_VLC_ROW(t_huffman_env_bal_1_5dB
),
106 SBR_VLC_ROW(f_huffman_env_bal_1_5dB
),
107 SBR_VLC_ROW(t_huffman_env_3_0dB
),
108 SBR_VLC_ROW(f_huffman_env_3_0dB
),
109 SBR_VLC_ROW(t_huffman_env_bal_3_0dB
),
110 SBR_VLC_ROW(f_huffman_env_bal_3_0dB
),
111 SBR_VLC_ROW(t_huffman_noise_3_0dB
),
112 SBR_VLC_ROW(t_huffman_noise_bal_3_0dB
),
115 // SBR VLC table initialization
116 SBR_INIT_VLC_STATIC(0, 1098);
117 SBR_INIT_VLC_STATIC(1, 1092);
118 SBR_INIT_VLC_STATIC(2, 768);
119 SBR_INIT_VLC_STATIC(3, 1026);
120 SBR_INIT_VLC_STATIC(4, 1058);
121 SBR_INIT_VLC_STATIC(5, 1052);
122 SBR_INIT_VLC_STATIC(6, 544);
123 SBR_INIT_VLC_STATIC(7, 544);
124 SBR_INIT_VLC_STATIC(8, 592);
125 SBR_INIT_VLC_STATIC(9, 512);
132 /** Places SBR in pure upsampling mode. */
133 static void sbr_turnoff(SpectralBandReplication
*sbr
) {
135 // Init defults used in pure upsampling mode
136 sbr
->kx
[1] = 32; //Typo in spec, kx' inits to 32
138 // Reset values for first SBR header
139 sbr
->data
[0].e_a
[1] = sbr
->data
[1].e_a
[1] = -1;
140 memset(&sbr
->spectrum_params
, -1, sizeof(SpectrumParameters
));
143 av_cold
void ff_aac_sbr_ctx_init(AACContext
*ac
, SpectralBandReplication
*sbr
)
145 if(sbr
->mdct
.mdct_bits
)
147 sbr
->kx
[0] = sbr
->kx
[1];
149 sbr
->data
[0].synthesis_filterbank_samples_offset
= SBR_SYNTHESIS_BUF_SIZE
- (1280 - 128);
150 sbr
->data
[1].synthesis_filterbank_samples_offset
= SBR_SYNTHESIS_BUF_SIZE
- (1280 - 128);
151 /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
152 * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
153 * and scale back down at synthesis. */
154 ff_mdct_init(&sbr
->mdct
, 7, 1, 1.0 / (64 * 32768.0));
155 ff_mdct_init(&sbr
->mdct_ana
, 7, 1, -2.0 * 32768.0);
156 ff_ps_ctx_init(&sbr
->ps
);
157 ff_sbrdsp_init(&sbr
->dsp
);
158 aacsbr_func_ptr_init(&sbr
->c
);
161 av_cold
void ff_aac_sbr_ctx_close(SpectralBandReplication
*sbr
)
163 ff_mdct_end(&sbr
->mdct
);
164 ff_mdct_end(&sbr
->mdct_ana
);
167 static int qsort_comparison_function_int16(const void *a
, const void *b
)
169 return *(const int16_t *)a
- *(const int16_t *)b
;
172 static inline int in_table_int16(const int16_t *table
, int last_el
, int16_t needle
)
175 for (i
= 0; i
<= last_el
; i
++)
176 if (table
[i
] == needle
)
181 /// Limiter Frequency Band Table (14496-3 sp04 p198)
182 static void sbr_make_f_tablelim(SpectralBandReplication
*sbr
)
185 if (sbr
->bs_limiter_bands
> 0) {
186 static const float bands_warped
[3] = { 1.32715174233856803909f
, //2^(0.49/1.2)
187 1.18509277094158210129f
, //2^(0.49/2)
188 1.11987160404675912501f
}; //2^(0.49/3)
189 const float lim_bands_per_octave_warped
= bands_warped
[sbr
->bs_limiter_bands
- 1];
190 int16_t patch_borders
[7];
191 uint16_t *in
= sbr
->f_tablelim
+ 1, *out
= sbr
->f_tablelim
;
193 patch_borders
[0] = sbr
->kx
[1];
194 for (k
= 1; k
<= sbr
->num_patches
; k
++)
195 patch_borders
[k
] = patch_borders
[k
-1] + sbr
->patch_num_subbands
[k
-1];
197 memcpy(sbr
->f_tablelim
, sbr
->f_tablelow
,
198 (sbr
->n
[0] + 1) * sizeof(sbr
->f_tablelow
[0]));
199 if (sbr
->num_patches
> 1)
200 memcpy(sbr
->f_tablelim
+ sbr
->n
[0] + 1, patch_borders
+ 1,
201 (sbr
->num_patches
- 1) * sizeof(patch_borders
[0]));
203 qsort(sbr
->f_tablelim
, sbr
->num_patches
+ sbr
->n
[0],
204 sizeof(sbr
->f_tablelim
[0]),
205 qsort_comparison_function_int16
);
207 sbr
->n_lim
= sbr
->n
[0] + sbr
->num_patches
- 1;
208 while (out
< sbr
->f_tablelim
+ sbr
->n_lim
) {
209 if (*in
>= *out
* lim_bands_per_octave_warped
) {
211 } else if (*in
== *out
||
212 !in_table_int16(patch_borders
, sbr
->num_patches
, *in
)) {
215 } else if (!in_table_int16(patch_borders
, sbr
->num_patches
, *out
)) {
223 sbr
->f_tablelim
[0] = sbr
->f_tablelow
[0];
224 sbr
->f_tablelim
[1] = sbr
->f_tablelow
[sbr
->n
[0]];
229 static unsigned int read_sbr_header(SpectralBandReplication
*sbr
, GetBitContext
*gb
)
231 unsigned int cnt
= get_bits_count(gb
);
232 uint8_t bs_header_extra_1
;
233 uint8_t bs_header_extra_2
;
234 int old_bs_limiter_bands
= sbr
->bs_limiter_bands
;
235 SpectrumParameters old_spectrum_params
;
239 // Save last spectrum parameters variables to compare to new ones
240 memcpy(&old_spectrum_params
, &sbr
->spectrum_params
, sizeof(SpectrumParameters
));
242 sbr
->bs_amp_res_header
= get_bits1(gb
);
243 sbr
->spectrum_params
.bs_start_freq
= get_bits(gb
, 4);
244 sbr
->spectrum_params
.bs_stop_freq
= get_bits(gb
, 4);
245 sbr
->spectrum_params
.bs_xover_band
= get_bits(gb
, 3);
246 skip_bits(gb
, 2); // bs_reserved
248 bs_header_extra_1
= get_bits1(gb
);
249 bs_header_extra_2
= get_bits1(gb
);
251 if (bs_header_extra_1
) {
252 sbr
->spectrum_params
.bs_freq_scale
= get_bits(gb
, 2);
253 sbr
->spectrum_params
.bs_alter_scale
= get_bits1(gb
);
254 sbr
->spectrum_params
.bs_noise_bands
= get_bits(gb
, 2);
256 sbr
->spectrum_params
.bs_freq_scale
= 2;
257 sbr
->spectrum_params
.bs_alter_scale
= 1;
258 sbr
->spectrum_params
.bs_noise_bands
= 2;
261 // Check if spectrum parameters changed
262 if (memcmp(&old_spectrum_params
, &sbr
->spectrum_params
, sizeof(SpectrumParameters
)))
265 if (bs_header_extra_2
) {
266 sbr
->bs_limiter_bands
= get_bits(gb
, 2);
267 sbr
->bs_limiter_gains
= get_bits(gb
, 2);
268 sbr
->bs_interpol_freq
= get_bits1(gb
);
269 sbr
->bs_smoothing_mode
= get_bits1(gb
);
271 sbr
->bs_limiter_bands
= 2;
272 sbr
->bs_limiter_gains
= 2;
273 sbr
->bs_interpol_freq
= 1;
274 sbr
->bs_smoothing_mode
= 1;
277 if (sbr
->bs_limiter_bands
!= old_bs_limiter_bands
&& !sbr
->reset
)
278 sbr_make_f_tablelim(sbr
);
280 return get_bits_count(gb
) - cnt
;
283 static int array_min_int16(const int16_t *array
, int nel
)
285 int i
, min
= array
[0];
286 for (i
= 1; i
< nel
; i
++)
287 min
= FFMIN(array
[i
], min
);
291 static void make_bands(int16_t* bands
, int start
, int stop
, int num_bands
)
293 int k
, previous
, present
;
296 base
= powf((float)stop
/ start
, 1.0f
/ num_bands
);
300 for (k
= 0; k
< num_bands
-1; k
++) {
302 present
= lrintf(prod
);
303 bands
[k
] = present
- previous
;
306 bands
[num_bands
-1] = stop
- previous
;
309 static int check_n_master(AVCodecContext
*avctx
, int n_master
, int bs_xover_band
)
311 // Requirements (14496-3 sp04 p205)
313 av_log(avctx
, AV_LOG_ERROR
, "Invalid n_master: %d\n", n_master
);
316 if (bs_xover_band
>= n_master
) {
317 av_log(avctx
, AV_LOG_ERROR
,
318 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
325 /// Master Frequency Band Table (14496-3 sp04 p194)
326 static int sbr_make_f_master(AACContext
*ac
, SpectralBandReplication
*sbr
,
327 SpectrumParameters
*spectrum
)
329 unsigned int temp
, max_qmf_subbands
;
330 unsigned int start_min
, stop_min
;
332 const int8_t *sbr_offset_ptr
;
335 if (sbr
->sample_rate
< 32000) {
337 } else if (sbr
->sample_rate
< 64000) {
342 switch (sbr
->sample_rate
) {
344 sbr_offset_ptr
= sbr_offset
[0];
347 sbr_offset_ptr
= sbr_offset
[1];
350 sbr_offset_ptr
= sbr_offset
[2];
353 sbr_offset_ptr
= sbr_offset
[3];
355 case 44100: case 48000: case 64000:
356 sbr_offset_ptr
= sbr_offset
[4];
358 case 88200: case 96000: case 128000: case 176400: case 192000:
359 sbr_offset_ptr
= sbr_offset
[5];
362 av_log(ac
->avctx
, AV_LOG_ERROR
,
363 "Unsupported sample rate for SBR: %d\n", sbr
->sample_rate
);
367 start_min
= ((temp
<< 7) + (sbr
->sample_rate
>> 1)) / sbr
->sample_rate
;
368 stop_min
= ((temp
<< 8) + (sbr
->sample_rate
>> 1)) / sbr
->sample_rate
;
370 sbr
->k
[0] = start_min
+ sbr_offset_ptr
[spectrum
->bs_start_freq
];
372 if (spectrum
->bs_stop_freq
< 14) {
373 sbr
->k
[2] = stop_min
;
374 make_bands(stop_dk
, stop_min
, 64, 13);
375 qsort(stop_dk
, 13, sizeof(stop_dk
[0]), qsort_comparison_function_int16
);
376 for (k
= 0; k
< spectrum
->bs_stop_freq
; k
++)
377 sbr
->k
[2] += stop_dk
[k
];
378 } else if (spectrum
->bs_stop_freq
== 14) {
379 sbr
->k
[2] = 2*sbr
->k
[0];
380 } else if (spectrum
->bs_stop_freq
== 15) {
381 sbr
->k
[2] = 3*sbr
->k
[0];
383 av_log(ac
->avctx
, AV_LOG_ERROR
,
384 "Invalid bs_stop_freq: %d\n", spectrum
->bs_stop_freq
);
387 sbr
->k
[2] = FFMIN(64, sbr
->k
[2]);
389 // Requirements (14496-3 sp04 p205)
390 if (sbr
->sample_rate
<= 32000) {
391 max_qmf_subbands
= 48;
392 } else if (sbr
->sample_rate
== 44100) {
393 max_qmf_subbands
= 35;
394 } else if (sbr
->sample_rate
>= 48000)
395 max_qmf_subbands
= 32;
399 if (sbr
->k
[2] - sbr
->k
[0] > max_qmf_subbands
) {
400 av_log(ac
->avctx
, AV_LOG_ERROR
,
401 "Invalid bitstream, too many QMF subbands: %d\n", sbr
->k
[2] - sbr
->k
[0]);
405 if (!spectrum
->bs_freq_scale
) {
408 dk
= spectrum
->bs_alter_scale
+ 1;
409 sbr
->n_master
= ((sbr
->k
[2] - sbr
->k
[0] + (dk
&2)) >> dk
) << 1;
410 if (check_n_master(ac
->avctx
, sbr
->n_master
, sbr
->spectrum_params
.bs_xover_band
))
413 for (k
= 1; k
<= sbr
->n_master
; k
++)
414 sbr
->f_master
[k
] = dk
;
416 k2diff
= sbr
->k
[2] - sbr
->k
[0] - sbr
->n_master
* dk
;
419 sbr
->f_master
[2]-= (k2diff
< -1);
421 sbr
->f_master
[sbr
->n_master
]++;
424 sbr
->f_master
[0] = sbr
->k
[0];
425 for (k
= 1; k
<= sbr
->n_master
; k
++)
426 sbr
->f_master
[k
] += sbr
->f_master
[k
- 1];
429 int half_bands
= 7 - spectrum
->bs_freq_scale
; // bs_freq_scale = {1,2,3}
430 int two_regions
, num_bands_0
;
431 int vdk0_max
, vdk1_min
;
434 if (49 * sbr
->k
[2] > 110 * sbr
->k
[0]) {
436 sbr
->k
[1] = 2 * sbr
->k
[0];
439 sbr
->k
[1] = sbr
->k
[2];
442 num_bands_0
= lrintf(half_bands
* log2f(sbr
->k
[1] / (float)sbr
->k
[0])) * 2;
444 if (num_bands_0
<= 0) { // Requirements (14496-3 sp04 p205)
445 av_log(ac
->avctx
, AV_LOG_ERROR
, "Invalid num_bands_0: %d\n", num_bands_0
);
451 make_bands(vk0
+1, sbr
->k
[0], sbr
->k
[1], num_bands_0
);
453 qsort(vk0
+ 1, num_bands_0
, sizeof(vk0
[1]), qsort_comparison_function_int16
);
454 vdk0_max
= vk0
[num_bands_0
];
457 for (k
= 1; k
<= num_bands_0
; k
++) {
458 if (vk0
[k
] <= 0) { // Requirements (14496-3 sp04 p205)
459 av_log(ac
->avctx
, AV_LOG_ERROR
, "Invalid vDk0[%d]: %d\n", k
, vk0
[k
]);
467 float invwarp
= spectrum
->bs_alter_scale
? 0.76923076923076923077f
468 : 1.0f
; // bs_alter_scale = {0,1}
469 int num_bands_1
= lrintf(half_bands
* invwarp
*
470 log2f(sbr
->k
[2] / (float)sbr
->k
[1])) * 2;
472 make_bands(vk1
+1, sbr
->k
[1], sbr
->k
[2], num_bands_1
);
474 vdk1_min
= array_min_int16(vk1
+ 1, num_bands_1
);
476 if (vdk1_min
< vdk0_max
) {
478 qsort(vk1
+ 1, num_bands_1
, sizeof(vk1
[1]), qsort_comparison_function_int16
);
479 change
= FFMIN(vdk0_max
- vk1
[1], (vk1
[num_bands_1
] - vk1
[1]) >> 1);
481 vk1
[num_bands_1
] -= change
;
484 qsort(vk1
+ 1, num_bands_1
, sizeof(vk1
[1]), qsort_comparison_function_int16
);
487 for (k
= 1; k
<= num_bands_1
; k
++) {
488 if (vk1
[k
] <= 0) { // Requirements (14496-3 sp04 p205)
489 av_log(ac
->avctx
, AV_LOG_ERROR
, "Invalid vDk1[%d]: %d\n", k
, vk1
[k
]);
495 sbr
->n_master
= num_bands_0
+ num_bands_1
;
496 if (check_n_master(ac
->avctx
, sbr
->n_master
, sbr
->spectrum_params
.bs_xover_band
))
498 memcpy(&sbr
->f_master
[0], vk0
,
499 (num_bands_0
+ 1) * sizeof(sbr
->f_master
[0]));
500 memcpy(&sbr
->f_master
[num_bands_0
+ 1], vk1
+ 1,
501 num_bands_1
* sizeof(sbr
->f_master
[0]));
504 sbr
->n_master
= num_bands_0
;
505 if (check_n_master(ac
->avctx
, sbr
->n_master
, sbr
->spectrum_params
.bs_xover_band
))
507 memcpy(sbr
->f_master
, vk0
, (num_bands_0
+ 1) * sizeof(sbr
->f_master
[0]));
514 /// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
515 static int sbr_hf_calc_npatches(AACContext
*ac
, SpectralBandReplication
*sbr
)
519 int usb
= sbr
->kx
[1];
520 int goal_sb
= ((1000 << 11) + (sbr
->sample_rate
>> 1)) / sbr
->sample_rate
;
522 sbr
->num_patches
= 0;
524 if (goal_sb
< sbr
->kx
[1] + sbr
->m
[1]) {
525 for (k
= 0; sbr
->f_master
[k
] < goal_sb
; k
++) ;
531 for (i
= k
; i
== k
|| sb
> (sbr
->k
[0] - 1 + msb
- odd
); i
--) {
532 sb
= sbr
->f_master
[i
];
533 odd
= (sb
+ sbr
->k
[0]) & 1;
536 // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
537 // After this check the final number of patches can still be six which is
538 // illegal however the Coding Technologies decoder check stream has a final
539 // count of 6 patches
540 if (sbr
->num_patches
> 5) {
541 av_log(ac
->avctx
, AV_LOG_ERROR
, "Too many patches: %d\n", sbr
->num_patches
);
545 sbr
->patch_num_subbands
[sbr
->num_patches
] = FFMAX(sb
- usb
, 0);
546 sbr
->patch_start_subband
[sbr
->num_patches
] = sbr
->k
[0] - odd
- sbr
->patch_num_subbands
[sbr
->num_patches
];
548 if (sbr
->patch_num_subbands
[sbr
->num_patches
] > 0) {
555 if (sbr
->f_master
[k
] - sb
< 3)
557 } while (sb
!= sbr
->kx
[1] + sbr
->m
[1]);
559 if (sbr
->num_patches
> 1 && sbr
->patch_num_subbands
[sbr
->num_patches
-1] < 3)
565 /// Derived Frequency Band Tables (14496-3 sp04 p197)
566 static int sbr_make_f_derived(AACContext
*ac
, SpectralBandReplication
*sbr
)
570 sbr
->n
[1] = sbr
->n_master
- sbr
->spectrum_params
.bs_xover_band
;
571 sbr
->n
[0] = (sbr
->n
[1] + 1) >> 1;
573 memcpy(sbr
->f_tablehigh
, &sbr
->f_master
[sbr
->spectrum_params
.bs_xover_band
],
574 (sbr
->n
[1] + 1) * sizeof(sbr
->f_master
[0]));
575 sbr
->m
[1] = sbr
->f_tablehigh
[sbr
->n
[1]] - sbr
->f_tablehigh
[0];
576 sbr
->kx
[1] = sbr
->f_tablehigh
[0];
578 // Requirements (14496-3 sp04 p205)
579 if (sbr
->kx
[1] + sbr
->m
[1] > 64) {
580 av_log(ac
->avctx
, AV_LOG_ERROR
,
581 "Stop frequency border too high: %d\n", sbr
->kx
[1] + sbr
->m
[1]);
584 if (sbr
->kx
[1] > 32) {
585 av_log(ac
->avctx
, AV_LOG_ERROR
, "Start frequency border too high: %d\n", sbr
->kx
[1]);
589 sbr
->f_tablelow
[0] = sbr
->f_tablehigh
[0];
590 temp
= sbr
->n
[1] & 1;
591 for (k
= 1; k
<= sbr
->n
[0]; k
++)
592 sbr
->f_tablelow
[k
] = sbr
->f_tablehigh
[2 * k
- temp
];
594 sbr
->n_q
= FFMAX(1, lrintf(sbr
->spectrum_params
.bs_noise_bands
*
595 log2f(sbr
->k
[2] / (float)sbr
->kx
[1]))); // 0 <= bs_noise_bands <= 3
597 av_log(ac
->avctx
, AV_LOG_ERROR
, "Too many noise floor scale factors: %d\n", sbr
->n_q
);
601 sbr
->f_tablenoise
[0] = sbr
->f_tablelow
[0];
603 for (k
= 1; k
<= sbr
->n_q
; k
++) {
604 temp
+= (sbr
->n
[0] - temp
) / (sbr
->n_q
+ 1 - k
);
605 sbr
->f_tablenoise
[k
] = sbr
->f_tablelow
[temp
];
608 if (sbr_hf_calc_npatches(ac
, sbr
) < 0)
611 sbr_make_f_tablelim(sbr
);
613 sbr
->data
[0].f_indexnoise
= 0;
614 sbr
->data
[1].f_indexnoise
= 0;
619 static av_always_inline
void get_bits1_vector(GetBitContext
*gb
, uint8_t *vec
,
623 for (i
= 0; i
< elements
; i
++) {
624 vec
[i
] = get_bits1(gb
);
628 /** ceil(log2(index+1)) */
629 static const int8_t ceil_log2
[] = {
633 static int read_sbr_grid(AACContext
*ac
, SpectralBandReplication
*sbr
,
634 GetBitContext
*gb
, SBRData
*ch_data
)
637 unsigned bs_pointer
= 0;
638 // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
639 int abs_bord_trail
= 16;
640 int num_rel_lead
, num_rel_trail
;
641 unsigned bs_num_env_old
= ch_data
->bs_num_env
;
643 ch_data
->bs_freq_res
[0] = ch_data
->bs_freq_res
[ch_data
->bs_num_env
];
644 ch_data
->bs_amp_res
= sbr
->bs_amp_res_header
;
645 ch_data
->t_env_num_env_old
= ch_data
->t_env
[bs_num_env_old
];
647 switch (ch_data
->bs_frame_class
= get_bits(gb
, 2)) {
649 ch_data
->bs_num_env
= 1 << get_bits(gb
, 2);
650 num_rel_lead
= ch_data
->bs_num_env
- 1;
651 if (ch_data
->bs_num_env
== 1)
652 ch_data
->bs_amp_res
= 0;
654 if (ch_data
->bs_num_env
> 4) {
655 av_log(ac
->avctx
, AV_LOG_ERROR
,
656 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
657 ch_data
->bs_num_env
);
661 ch_data
->t_env
[0] = 0;
662 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
664 abs_bord_trail
= (abs_bord_trail
+ (ch_data
->bs_num_env
>> 1)) /
666 for (i
= 0; i
< num_rel_lead
; i
++)
667 ch_data
->t_env
[i
+ 1] = ch_data
->t_env
[i
] + abs_bord_trail
;
669 ch_data
->bs_freq_res
[1] = get_bits1(gb
);
670 for (i
= 1; i
< ch_data
->bs_num_env
; i
++)
671 ch_data
->bs_freq_res
[i
+ 1] = ch_data
->bs_freq_res
[1];
674 abs_bord_trail
+= get_bits(gb
, 2);
675 num_rel_trail
= get_bits(gb
, 2);
676 ch_data
->bs_num_env
= num_rel_trail
+ 1;
677 ch_data
->t_env
[0] = 0;
678 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
680 for (i
= 0; i
< num_rel_trail
; i
++)
681 ch_data
->t_env
[ch_data
->bs_num_env
- 1 - i
] =
682 ch_data
->t_env
[ch_data
->bs_num_env
- i
] - 2 * get_bits(gb
, 2) - 2;
684 bs_pointer
= get_bits(gb
, ceil_log2
[ch_data
->bs_num_env
]);
686 for (i
= 0; i
< ch_data
->bs_num_env
; i
++)
687 ch_data
->bs_freq_res
[ch_data
->bs_num_env
- i
] = get_bits1(gb
);
690 ch_data
->t_env
[0] = get_bits(gb
, 2);
691 num_rel_lead
= get_bits(gb
, 2);
692 ch_data
->bs_num_env
= num_rel_lead
+ 1;
693 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
695 for (i
= 0; i
< num_rel_lead
; i
++)
696 ch_data
->t_env
[i
+ 1] = ch_data
->t_env
[i
] + 2 * get_bits(gb
, 2) + 2;
698 bs_pointer
= get_bits(gb
, ceil_log2
[ch_data
->bs_num_env
]);
700 get_bits1_vector(gb
, ch_data
->bs_freq_res
+ 1, ch_data
->bs_num_env
);
703 ch_data
->t_env
[0] = get_bits(gb
, 2);
704 abs_bord_trail
+= get_bits(gb
, 2);
705 num_rel_lead
= get_bits(gb
, 2);
706 num_rel_trail
= get_bits(gb
, 2);
707 ch_data
->bs_num_env
= num_rel_lead
+ num_rel_trail
+ 1;
709 if (ch_data
->bs_num_env
> 5) {
710 av_log(ac
->avctx
, AV_LOG_ERROR
,
711 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
712 ch_data
->bs_num_env
);
716 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
718 for (i
= 0; i
< num_rel_lead
; i
++)
719 ch_data
->t_env
[i
+ 1] = ch_data
->t_env
[i
] + 2 * get_bits(gb
, 2) + 2;
720 for (i
= 0; i
< num_rel_trail
; i
++)
721 ch_data
->t_env
[ch_data
->bs_num_env
- 1 - i
] =
722 ch_data
->t_env
[ch_data
->bs_num_env
- i
] - 2 * get_bits(gb
, 2) - 2;
724 bs_pointer
= get_bits(gb
, ceil_log2
[ch_data
->bs_num_env
]);
726 get_bits1_vector(gb
, ch_data
->bs_freq_res
+ 1, ch_data
->bs_num_env
);
730 if (bs_pointer
> ch_data
->bs_num_env
+ 1) {
731 av_log(ac
->avctx
, AV_LOG_ERROR
,
732 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
737 for (i
= 1; i
<= ch_data
->bs_num_env
; i
++) {
738 if (ch_data
->t_env
[i
-1] > ch_data
->t_env
[i
]) {
739 av_log(ac
->avctx
, AV_LOG_ERROR
, "Non monotone time borders\n");
744 ch_data
->bs_num_noise
= (ch_data
->bs_num_env
> 1) + 1;
746 ch_data
->t_q
[0] = ch_data
->t_env
[0];
747 ch_data
->t_q
[ch_data
->bs_num_noise
] = ch_data
->t_env
[ch_data
->bs_num_env
];
748 if (ch_data
->bs_num_noise
> 1) {
750 if (ch_data
->bs_frame_class
== FIXFIX
) {
751 idx
= ch_data
->bs_num_env
>> 1;
752 } else if (ch_data
->bs_frame_class
& 1) { // FIXVAR or VARVAR
753 idx
= ch_data
->bs_num_env
- FFMAX((int)bs_pointer
- 1, 1);
757 else if (bs_pointer
== 1)
758 idx
= ch_data
->bs_num_env
- 1;
759 else // bs_pointer > 1
760 idx
= bs_pointer
- 1;
762 ch_data
->t_q
[1] = ch_data
->t_env
[idx
];
765 ch_data
->e_a
[0] = -(ch_data
->e_a
[1] != bs_num_env_old
); // l_APrev
766 ch_data
->e_a
[1] = -1;
767 if ((ch_data
->bs_frame_class
& 1) && bs_pointer
) { // FIXVAR or VARVAR and bs_pointer != 0
768 ch_data
->e_a
[1] = ch_data
->bs_num_env
+ 1 - bs_pointer
;
769 } else if ((ch_data
->bs_frame_class
== 2) && (bs_pointer
> 1)) // VARFIX and bs_pointer > 1
770 ch_data
->e_a
[1] = bs_pointer
- 1;
775 static void copy_sbr_grid(SBRData
*dst
, const SBRData
*src
) {
776 //These variables are saved from the previous frame rather than copied
777 dst
->bs_freq_res
[0] = dst
->bs_freq_res
[dst
->bs_num_env
];
778 dst
->t_env_num_env_old
= dst
->t_env
[dst
->bs_num_env
];
779 dst
->e_a
[0] = -(dst
->e_a
[1] != dst
->bs_num_env
);
781 //These variables are read from the bitstream and therefore copied
782 memcpy(dst
->bs_freq_res
+1, src
->bs_freq_res
+1, sizeof(dst
->bs_freq_res
)-sizeof(*dst
->bs_freq_res
));
783 memcpy(dst
->t_env
, src
->t_env
, sizeof(dst
->t_env
));
784 memcpy(dst
->t_q
, src
->t_q
, sizeof(dst
->t_q
));
785 dst
->bs_num_env
= src
->bs_num_env
;
786 dst
->bs_amp_res
= src
->bs_amp_res
;
787 dst
->bs_num_noise
= src
->bs_num_noise
;
788 dst
->bs_frame_class
= src
->bs_frame_class
;
789 dst
->e_a
[1] = src
->e_a
[1];
792 /// Read how the envelope and noise floor data is delta coded
793 static void read_sbr_dtdf(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
796 get_bits1_vector(gb
, ch_data
->bs_df_env
, ch_data
->bs_num_env
);
797 get_bits1_vector(gb
, ch_data
->bs_df_noise
, ch_data
->bs_num_noise
);
800 /// Read inverse filtering data
801 static void read_sbr_invf(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
806 memcpy(ch_data
->bs_invf_mode
[1], ch_data
->bs_invf_mode
[0], 5 * sizeof(uint8_t));
807 for (i
= 0; i
< sbr
->n_q
; i
++)
808 ch_data
->bs_invf_mode
[0][i
] = get_bits(gb
, 2);
811 static void read_sbr_envelope(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
812 SBRData
*ch_data
, int ch
)
816 VLC_TYPE (*t_huff
)[2], (*f_huff
)[2];
818 const int delta
= (ch
== 1 && sbr
->bs_coupling
== 1) + 1;
819 const int odd
= sbr
->n
[1] & 1;
821 if (sbr
->bs_coupling
&& ch
) {
822 if (ch_data
->bs_amp_res
) {
824 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_BAL_3_0DB
].table
;
825 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_BAL_3_0DB
];
826 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_BAL_3_0DB
].table
;
827 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_BAL_3_0DB
];
830 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_BAL_1_5DB
].table
;
831 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_BAL_1_5DB
];
832 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_BAL_1_5DB
].table
;
833 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_BAL_1_5DB
];
836 if (ch_data
->bs_amp_res
) {
838 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_3_0DB
].table
;
839 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_3_0DB
];
840 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_3_0DB
].table
;
841 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_3_0DB
];
844 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_1_5DB
].table
;
845 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_1_5DB
];
846 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_1_5DB
].table
;
847 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_1_5DB
];
851 for (i
= 0; i
< ch_data
->bs_num_env
; i
++) {
852 if (ch_data
->bs_df_env
[i
]) {
853 // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
854 if (ch_data
->bs_freq_res
[i
+ 1] == ch_data
->bs_freq_res
[i
]) {
855 for (j
= 0; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++)
856 ch_data
->env_facs
[i
+ 1][j
] = ch_data
->env_facs
[i
][j
] + delta
* (get_vlc2(gb
, t_huff
, 9, 3) - t_lav
);
857 } else if (ch_data
->bs_freq_res
[i
+ 1]) {
858 for (j
= 0; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++) {
859 k
= (j
+ odd
) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
860 ch_data
->env_facs
[i
+ 1][j
] = ch_data
->env_facs
[i
][k
] + delta
* (get_vlc2(gb
, t_huff
, 9, 3) - t_lav
);
863 for (j
= 0; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++) {
864 k
= j
? 2*j
- odd
: 0; // find k such that f_tablehigh[k] == f_tablelow[j]
865 ch_data
->env_facs
[i
+ 1][j
] = ch_data
->env_facs
[i
][k
] + delta
* (get_vlc2(gb
, t_huff
, 9, 3) - t_lav
);
869 ch_data
->env_facs
[i
+ 1][0] = delta
* get_bits(gb
, bits
); // bs_env_start_value_balance
870 for (j
= 1; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++)
871 ch_data
->env_facs
[i
+ 1][j
] = ch_data
->env_facs
[i
+ 1][j
- 1] + delta
* (get_vlc2(gb
, f_huff
, 9, 3) - f_lav
);
875 //assign 0th elements of env_facs from last elements
876 memcpy(ch_data
->env_facs
[0], ch_data
->env_facs
[ch_data
->bs_num_env
],
877 sizeof(ch_data
->env_facs
[0]));
880 static void read_sbr_noise(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
881 SBRData
*ch_data
, int ch
)
884 VLC_TYPE (*t_huff
)[2], (*f_huff
)[2];
886 int delta
= (ch
== 1 && sbr
->bs_coupling
== 1) + 1;
888 if (sbr
->bs_coupling
&& ch
) {
889 t_huff
= vlc_sbr
[T_HUFFMAN_NOISE_BAL_3_0DB
].table
;
890 t_lav
= vlc_sbr_lav
[T_HUFFMAN_NOISE_BAL_3_0DB
];
891 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_BAL_3_0DB
].table
;
892 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_BAL_3_0DB
];
894 t_huff
= vlc_sbr
[T_HUFFMAN_NOISE_3_0DB
].table
;
895 t_lav
= vlc_sbr_lav
[T_HUFFMAN_NOISE_3_0DB
];
896 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_3_0DB
].table
;
897 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_3_0DB
];
900 for (i
= 0; i
< ch_data
->bs_num_noise
; i
++) {
901 if (ch_data
->bs_df_noise
[i
]) {
902 for (j
= 0; j
< sbr
->n_q
; j
++)
903 ch_data
->noise_facs
[i
+ 1][j
] = ch_data
->noise_facs
[i
][j
] + delta
* (get_vlc2(gb
, t_huff
, 9, 2) - t_lav
);
905 ch_data
->noise_facs
[i
+ 1][0] = delta
* get_bits(gb
, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
906 for (j
= 1; j
< sbr
->n_q
; j
++)
907 ch_data
->noise_facs
[i
+ 1][j
] = ch_data
->noise_facs
[i
+ 1][j
- 1] + delta
* (get_vlc2(gb
, f_huff
, 9, 3) - f_lav
);
911 //assign 0th elements of noise_facs from last elements
912 memcpy(ch_data
->noise_facs
[0], ch_data
->noise_facs
[ch_data
->bs_num_noise
],
913 sizeof(ch_data
->noise_facs
[0]));
916 static void read_sbr_extension(AACContext
*ac
, SpectralBandReplication
*sbr
,
918 int bs_extension_id
, int *num_bits_left
)
920 switch (bs_extension_id
) {
921 case EXTENSION_ID_PS
:
922 if (!ac
->oc
[1].m4ac
.ps
) {
923 av_log(ac
->avctx
, AV_LOG_ERROR
, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
924 skip_bits_long(gb
, *num_bits_left
); // bs_fill_bits
928 *num_bits_left
-= ff_ps_read_data(ac
->avctx
, gb
, &sbr
->ps
, *num_bits_left
);
929 ac
->avctx
->profile
= FF_PROFILE_AAC_HE_V2
;
931 avpriv_report_missing_feature(ac
->avctx
, "Parametric Stereo");
932 skip_bits_long(gb
, *num_bits_left
); // bs_fill_bits
938 // some files contain 0-padding
939 if (bs_extension_id
|| *num_bits_left
> 16 || show_bits(gb
, *num_bits_left
))
940 avpriv_request_sample(ac
->avctx
, "Reserved SBR extensions");
941 skip_bits_long(gb
, *num_bits_left
); // bs_fill_bits
947 static int read_sbr_single_channel_element(AACContext
*ac
,
948 SpectralBandReplication
*sbr
,
951 if (get_bits1(gb
)) // bs_data_extra
952 skip_bits(gb
, 4); // bs_reserved
954 if (read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[0]))
956 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[0]);
957 read_sbr_invf(sbr
, gb
, &sbr
->data
[0]);
958 read_sbr_envelope(sbr
, gb
, &sbr
->data
[0], 0);
959 read_sbr_noise(sbr
, gb
, &sbr
->data
[0], 0);
961 if ((sbr
->data
[0].bs_add_harmonic_flag
= get_bits1(gb
)))
962 get_bits1_vector(gb
, sbr
->data
[0].bs_add_harmonic
, sbr
->n
[1]);
967 static int read_sbr_channel_pair_element(AACContext
*ac
,
968 SpectralBandReplication
*sbr
,
971 if (get_bits1(gb
)) // bs_data_extra
972 skip_bits(gb
, 8); // bs_reserved
974 if ((sbr
->bs_coupling
= get_bits1(gb
))) {
975 if (read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[0]))
977 copy_sbr_grid(&sbr
->data
[1], &sbr
->data
[0]);
978 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[0]);
979 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[1]);
980 read_sbr_invf(sbr
, gb
, &sbr
->data
[0]);
981 memcpy(sbr
->data
[1].bs_invf_mode
[1], sbr
->data
[1].bs_invf_mode
[0], sizeof(sbr
->data
[1].bs_invf_mode
[0]));
982 memcpy(sbr
->data
[1].bs_invf_mode
[0], sbr
->data
[0].bs_invf_mode
[0], sizeof(sbr
->data
[1].bs_invf_mode
[0]));
983 read_sbr_envelope(sbr
, gb
, &sbr
->data
[0], 0);
984 read_sbr_noise(sbr
, gb
, &sbr
->data
[0], 0);
985 read_sbr_envelope(sbr
, gb
, &sbr
->data
[1], 1);
986 read_sbr_noise(sbr
, gb
, &sbr
->data
[1], 1);
988 if (read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[0]) ||
989 read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[1]))
991 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[0]);
992 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[1]);
993 read_sbr_invf(sbr
, gb
, &sbr
->data
[0]);
994 read_sbr_invf(sbr
, gb
, &sbr
->data
[1]);
995 read_sbr_envelope(sbr
, gb
, &sbr
->data
[0], 0);
996 read_sbr_envelope(sbr
, gb
, &sbr
->data
[1], 1);
997 read_sbr_noise(sbr
, gb
, &sbr
->data
[0], 0);
998 read_sbr_noise(sbr
, gb
, &sbr
->data
[1], 1);
1001 if ((sbr
->data
[0].bs_add_harmonic_flag
= get_bits1(gb
)))
1002 get_bits1_vector(gb
, sbr
->data
[0].bs_add_harmonic
, sbr
->n
[1]);
1003 if ((sbr
->data
[1].bs_add_harmonic_flag
= get_bits1(gb
)))
1004 get_bits1_vector(gb
, sbr
->data
[1].bs_add_harmonic
, sbr
->n
[1]);
1009 static unsigned int read_sbr_data(AACContext
*ac
, SpectralBandReplication
*sbr
,
1010 GetBitContext
*gb
, int id_aac
)
1012 unsigned int cnt
= get_bits_count(gb
);
1014 if (id_aac
== TYPE_SCE
|| id_aac
== TYPE_CCE
) {
1015 if (read_sbr_single_channel_element(ac
, sbr
, gb
)) {
1017 return get_bits_count(gb
) - cnt
;
1019 } else if (id_aac
== TYPE_CPE
) {
1020 if (read_sbr_channel_pair_element(ac
, sbr
, gb
)) {
1022 return get_bits_count(gb
) - cnt
;
1025 av_log(ac
->avctx
, AV_LOG_ERROR
,
1026 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac
);
1028 return get_bits_count(gb
) - cnt
;
1030 if (get_bits1(gb
)) { // bs_extended_data
1031 int num_bits_left
= get_bits(gb
, 4); // bs_extension_size
1032 if (num_bits_left
== 15)
1033 num_bits_left
+= get_bits(gb
, 8); // bs_esc_count
1035 num_bits_left
<<= 3;
1036 while (num_bits_left
> 7) {
1038 read_sbr_extension(ac
, sbr
, gb
, get_bits(gb
, 2), &num_bits_left
); // bs_extension_id
1040 if (num_bits_left
< 0) {
1041 av_log(ac
->avctx
, AV_LOG_ERROR
, "SBR Extension over read.\n");
1043 if (num_bits_left
> 0)
1044 skip_bits(gb
, num_bits_left
);
1047 return get_bits_count(gb
) - cnt
;
1050 static void sbr_reset(AACContext
*ac
, SpectralBandReplication
*sbr
)
1053 err
= sbr_make_f_master(ac
, sbr
, &sbr
->spectrum_params
);
1055 err
= sbr_make_f_derived(ac
, sbr
);
1057 av_log(ac
->avctx
, AV_LOG_ERROR
,
1058 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1064 * Decode Spectral Band Replication extension data; reference: table 4.55.
1066 * @param crc flag indicating the presence of CRC checksum
1067 * @param cnt length of TYPE_FIL syntactic element in bytes
1069 * @return Returns number of bytes consumed from the TYPE_FIL element.
1071 int ff_decode_sbr_extension(AACContext
*ac
, SpectralBandReplication
*sbr
,
1072 GetBitContext
*gb_host
, int crc
, int cnt
, int id_aac
)
1074 unsigned int num_sbr_bits
= 0, num_align_bits
;
1075 unsigned bytes_read
;
1076 GetBitContext gbc
= *gb_host
, *gb
= &gbc
;
1077 skip_bits_long(gb_host
, cnt
*8 - 4);
1081 if (!sbr
->sample_rate
)
1082 sbr
->sample_rate
= 2 * ac
->oc
[1].m4ac
.sample_rate
; //TODO use the nominal sample rate for arbitrary sample rate support
1083 if (!ac
->oc
[1].m4ac
.ext_sample_rate
)
1084 ac
->oc
[1].m4ac
.ext_sample_rate
= 2 * ac
->oc
[1].m4ac
.sample_rate
;
1087 skip_bits(gb
, 10); // bs_sbr_crc_bits; TODO - implement CRC check
1091 //Save some state from the previous frame.
1092 sbr
->kx
[0] = sbr
->kx
[1];
1093 sbr
->m
[0] = sbr
->m
[1];
1094 sbr
->kx_and_m_pushed
= 1;
1097 if (get_bits1(gb
)) // bs_header_flag
1098 num_sbr_bits
+= read_sbr_header(sbr
, gb
);
1104 num_sbr_bits
+= read_sbr_data(ac
, sbr
, gb
, id_aac
);
1106 num_align_bits
= ((cnt
<< 3) - 4 - num_sbr_bits
) & 7;
1107 bytes_read
= ((num_sbr_bits
+ num_align_bits
+ 4) >> 3);
1109 if (bytes_read
> cnt
) {
1110 av_log(ac
->avctx
, AV_LOG_ERROR
,
1111 "Expected to read %d SBR bytes actually read %d.\n", cnt
, bytes_read
);
1116 /// Dequantization and stereo decoding (14496-3 sp04 p203)
1117 static void sbr_dequant(SpectralBandReplication
*sbr
, int id_aac
)
1122 if (id_aac
== TYPE_CPE
&& sbr
->bs_coupling
) {
1123 float alpha
= sbr
->data
[0].bs_amp_res
? 1.0f
: 0.5f
;
1124 float pan_offset
= sbr
->data
[0].bs_amp_res
? 12.0f
: 24.0f
;
1125 for (e
= 1; e
<= sbr
->data
[0].bs_num_env
; e
++) {
1126 for (k
= 0; k
< sbr
->n
[sbr
->data
[0].bs_freq_res
[e
]]; k
++) {
1127 float temp1
= exp2f(sbr
->data
[0].env_facs
[e
][k
] * alpha
+ 7.0f
);
1128 float temp2
= exp2f((pan_offset
- sbr
->data
[1].env_facs
[e
][k
]) * alpha
);
1131 av_log(NULL
, AV_LOG_ERROR
, "envelope scalefactor overflow in dequant\n");
1134 fac
= temp1
/ (1.0f
+ temp2
);
1135 sbr
->data
[0].env_facs
[e
][k
] = fac
;
1136 sbr
->data
[1].env_facs
[e
][k
] = fac
* temp2
;
1139 for (e
= 1; e
<= sbr
->data
[0].bs_num_noise
; e
++) {
1140 for (k
= 0; k
< sbr
->n_q
; k
++) {
1141 float temp1
= exp2f(NOISE_FLOOR_OFFSET
- sbr
->data
[0].noise_facs
[e
][k
] + 1);
1142 float temp2
= exp2f(12 - sbr
->data
[1].noise_facs
[e
][k
]);
1145 av_log(NULL
, AV_LOG_ERROR
, "envelope scalefactor overflow in dequant\n");
1148 fac
= temp1
/ (1.0f
+ temp2
);
1149 sbr
->data
[0].noise_facs
[e
][k
] = fac
;
1150 sbr
->data
[1].noise_facs
[e
][k
] = fac
* temp2
;
1153 } else { // SCE or one non-coupled CPE
1154 for (ch
= 0; ch
< (id_aac
== TYPE_CPE
) + 1; ch
++) {
1155 float alpha
= sbr
->data
[ch
].bs_amp_res
? 1.0f
: 0.5f
;
1156 for (e
= 1; e
<= sbr
->data
[ch
].bs_num_env
; e
++)
1157 for (k
= 0; k
< sbr
->n
[sbr
->data
[ch
].bs_freq_res
[e
]]; k
++){
1158 sbr
->data
[ch
].env_facs
[e
][k
] =
1159 exp2f(alpha
* sbr
->data
[ch
].env_facs
[e
][k
] + 6.0f
);
1160 if (sbr
->data
[ch
].env_facs
[e
][k
] > 1E20
) {
1161 av_log(NULL
, AV_LOG_ERROR
, "envelope scalefactor overflow in dequant\n");
1162 sbr
->data
[ch
].env_facs
[e
][k
] = 1;
1166 for (e
= 1; e
<= sbr
->data
[ch
].bs_num_noise
; e
++)
1167 for (k
= 0; k
< sbr
->n_q
; k
++)
1168 sbr
->data
[ch
].noise_facs
[e
][k
] =
1169 exp2f(NOISE_FLOOR_OFFSET
- sbr
->data
[ch
].noise_facs
[e
][k
]);
1175 * Analysis QMF Bank (14496-3 sp04 p206)
1177 * @param x pointer to the beginning of the first sample window
1178 * @param W array of complex-valued samples split into subbands
1180 #ifndef sbr_qmf_analysis
1181 static void sbr_qmf_analysis(AVFloatDSPContext
*dsp
, FFTContext
*mdct
,
1182 SBRDSPContext
*sbrdsp
, const float *in
, float *x
,
1183 float z
[320], float W
[2][32][32][2], int buf_idx
)
1186 memcpy(x
, x
+1024, (320-32)*sizeof(x
[0]));
1187 memcpy(x
+288, in
, 1024*sizeof(x
[0]));
1188 for (i
= 0; i
< 32; i
++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
1189 // are not supported
1190 dsp
->vector_fmul_reverse(z
, sbr_qmf_window_ds
, x
, 320);
1192 sbrdsp
->qmf_pre_shuffle(z
);
1193 mdct
->imdct_half(mdct
, z
, z
+64);
1194 sbrdsp
->qmf_post_shuffle(W
[buf_idx
][i
], z
);
1201 * Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank
1202 * (14496-3 sp04 p206)
1204 #ifndef sbr_qmf_synthesis
1205 static void sbr_qmf_synthesis(FFTContext
*mdct
,
1206 SBRDSPContext
*sbrdsp
, AVFloatDSPContext
*dsp
,
1207 float *out
, float X
[2][38][64],
1208 float mdct_buf
[2][64],
1209 float *v0
, int *v_off
, const unsigned int div
)
1212 const float *sbr_qmf_window
= div
? sbr_qmf_window_ds
: sbr_qmf_window_us
;
1213 const int step
= 128 >> div
;
1215 for (i
= 0; i
< 32; i
++) {
1216 if (*v_off
< step
) {
1217 int saved_samples
= (1280 - 128) >> div
;
1218 memcpy(&v0
[SBR_SYNTHESIS_BUF_SIZE
- saved_samples
], v0
, saved_samples
* sizeof(float));
1219 *v_off
= SBR_SYNTHESIS_BUF_SIZE
- saved_samples
- step
;
1225 for (n
= 0; n
< 32; n
++) {
1226 X
[0][i
][ n
] = -X
[0][i
][n
];
1227 X
[0][i
][32+n
] = X
[1][i
][31-n
];
1229 mdct
->imdct_half(mdct
, mdct_buf
[0], X
[0][i
]);
1230 sbrdsp
->qmf_deint_neg(v
, mdct_buf
[0]);
1232 sbrdsp
->neg_odd_64(X
[1][i
]);
1233 mdct
->imdct_half(mdct
, mdct_buf
[0], X
[0][i
]);
1234 mdct
->imdct_half(mdct
, mdct_buf
[1], X
[1][i
]);
1235 sbrdsp
->qmf_deint_bfly(v
, mdct_buf
[1], mdct_buf
[0]);
1237 dsp
->vector_fmul (out
, v
, sbr_qmf_window
, 64 >> div
);
1238 dsp
->vector_fmul_add(out
, v
+ ( 192 >> div
), sbr_qmf_window
+ ( 64 >> div
), out
, 64 >> div
);
1239 dsp
->vector_fmul_add(out
, v
+ ( 256 >> div
), sbr_qmf_window
+ (128 >> div
), out
, 64 >> div
);
1240 dsp
->vector_fmul_add(out
, v
+ ( 448 >> div
), sbr_qmf_window
+ (192 >> div
), out
, 64 >> div
);
1241 dsp
->vector_fmul_add(out
, v
+ ( 512 >> div
), sbr_qmf_window
+ (256 >> div
), out
, 64 >> div
);
1242 dsp
->vector_fmul_add(out
, v
+ ( 704 >> div
), sbr_qmf_window
+ (320 >> div
), out
, 64 >> div
);
1243 dsp
->vector_fmul_add(out
, v
+ ( 768 >> div
), sbr_qmf_window
+ (384 >> div
), out
, 64 >> div
);
1244 dsp
->vector_fmul_add(out
, v
+ ( 960 >> div
), sbr_qmf_window
+ (448 >> div
), out
, 64 >> div
);
1245 dsp
->vector_fmul_add(out
, v
+ (1024 >> div
), sbr_qmf_window
+ (512 >> div
), out
, 64 >> div
);
1246 dsp
->vector_fmul_add(out
, v
+ (1216 >> div
), sbr_qmf_window
+ (576 >> div
), out
, 64 >> div
);
1252 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
1253 * (14496-3 sp04 p214)
1254 * Warning: This routine does not seem numerically stable.
1256 static void sbr_hf_inverse_filter(SBRDSPContext
*dsp
,
1257 float (*alpha0
)[2], float (*alpha1
)[2],
1258 const float X_low
[32][40][2], int k0
)
1261 for (k
= 0; k
< k0
; k
++) {
1262 LOCAL_ALIGNED_16(float, phi
, [3], [2][2]);
1265 dsp
->autocorrelate(X_low
[k
], phi
);
1267 dk
= phi
[2][1][0] * phi
[1][0][0] -
1268 (phi
[1][1][0] * phi
[1][1][0] + phi
[1][1][1] * phi
[1][1][1]) / 1.000001f
;
1274 float temp_real
, temp_im
;
1275 temp_real
= phi
[0][0][0] * phi
[1][1][0] -
1276 phi
[0][0][1] * phi
[1][1][1] -
1277 phi
[0][1][0] * phi
[1][0][0];
1278 temp_im
= phi
[0][0][0] * phi
[1][1][1] +
1279 phi
[0][0][1] * phi
[1][1][0] -
1280 phi
[0][1][1] * phi
[1][0][0];
1282 alpha1
[k
][0] = temp_real
/ dk
;
1283 alpha1
[k
][1] = temp_im
/ dk
;
1286 if (!phi
[1][0][0]) {
1290 float temp_real
, temp_im
;
1291 temp_real
= phi
[0][0][0] + alpha1
[k
][0] * phi
[1][1][0] +
1292 alpha1
[k
][1] * phi
[1][1][1];
1293 temp_im
= phi
[0][0][1] + alpha1
[k
][1] * phi
[1][1][0] -
1294 alpha1
[k
][0] * phi
[1][1][1];
1296 alpha0
[k
][0] = -temp_real
/ phi
[1][0][0];
1297 alpha0
[k
][1] = -temp_im
/ phi
[1][0][0];
1300 if (alpha1
[k
][0] * alpha1
[k
][0] + alpha1
[k
][1] * alpha1
[k
][1] >= 16.0f
||
1301 alpha0
[k
][0] * alpha0
[k
][0] + alpha0
[k
][1] * alpha0
[k
][1] >= 16.0f
) {
1310 /// Chirp Factors (14496-3 sp04 p214)
1311 static void sbr_chirp(SpectralBandReplication
*sbr
, SBRData
*ch_data
)
1315 static const float bw_tab
[] = { 0.0f
, 0.75f
, 0.9f
, 0.98f
};
1317 for (i
= 0; i
< sbr
->n_q
; i
++) {
1318 if (ch_data
->bs_invf_mode
[0][i
] + ch_data
->bs_invf_mode
[1][i
] == 1) {
1321 new_bw
= bw_tab
[ch_data
->bs_invf_mode
[0][i
]];
1323 if (new_bw
< ch_data
->bw_array
[i
]) {
1324 new_bw
= 0.75f
* new_bw
+ 0.25f
* ch_data
->bw_array
[i
];
1326 new_bw
= 0.90625f
* new_bw
+ 0.09375f
* ch_data
->bw_array
[i
];
1327 ch_data
->bw_array
[i
] = new_bw
< 0.015625f
? 0.0f
: new_bw
;
1331 /// Generate the subband filtered lowband
1332 static int sbr_lf_gen(AACContext
*ac
, SpectralBandReplication
*sbr
,
1333 float X_low
[32][40][2], const float W
[2][32][32][2],
1337 const int t_HFGen
= 8;
1339 memset(X_low
, 0, 32*sizeof(*X_low
));
1340 for (k
= 0; k
< sbr
->kx
[1]; k
++) {
1341 for (i
= t_HFGen
; i
< i_f
+ t_HFGen
; i
++) {
1342 X_low
[k
][i
][0] = W
[buf_idx
][i
- t_HFGen
][k
][0];
1343 X_low
[k
][i
][1] = W
[buf_idx
][i
- t_HFGen
][k
][1];
1346 buf_idx
= 1-buf_idx
;
1347 for (k
= 0; k
< sbr
->kx
[0]; k
++) {
1348 for (i
= 0; i
< t_HFGen
; i
++) {
1349 X_low
[k
][i
][0] = W
[buf_idx
][i
+ i_f
- t_HFGen
][k
][0];
1350 X_low
[k
][i
][1] = W
[buf_idx
][i
+ i_f
- t_HFGen
][k
][1];
1356 /// High Frequency Generator (14496-3 sp04 p215)
1357 static int sbr_hf_gen(AACContext
*ac
, SpectralBandReplication
*sbr
,
1358 float X_high
[64][40][2], const float X_low
[32][40][2],
1359 const float (*alpha0
)[2], const float (*alpha1
)[2],
1360 const float bw_array
[5], const uint8_t *t_env
,
1366 for (j
= 0; j
< sbr
->num_patches
; j
++) {
1367 for (x
= 0; x
< sbr
->patch_num_subbands
[j
]; x
++, k
++) {
1368 const int p
= sbr
->patch_start_subband
[j
] + x
;
1369 while (g
<= sbr
->n_q
&& k
>= sbr
->f_tablenoise
[g
])
1374 av_log(ac
->avctx
, AV_LOG_ERROR
,
1375 "ERROR : no subband found for frequency %d\n", k
);
1379 sbr
->dsp
.hf_gen(X_high
[k
] + ENVELOPE_ADJUSTMENT_OFFSET
,
1380 X_low
[p
] + ENVELOPE_ADJUSTMENT_OFFSET
,
1381 alpha0
[p
], alpha1
[p
], bw_array
[g
],
1382 2 * t_env
[0], 2 * t_env
[bs_num_env
]);
1385 if (k
< sbr
->m
[1] + sbr
->kx
[1])
1386 memset(X_high
+ k
, 0, (sbr
->m
[1] + sbr
->kx
[1] - k
) * sizeof(*X_high
));
1391 /// Generate the subband filtered lowband
1392 static int sbr_x_gen(SpectralBandReplication
*sbr
, float X
[2][38][64],
1393 const float Y0
[38][64][2], const float Y1
[38][64][2],
1394 const float X_low
[32][40][2], int ch
)
1398 const int i_Temp
= FFMAX(2*sbr
->data
[ch
].t_env_num_env_old
- i_f
, 0);
1399 memset(X
, 0, 2*sizeof(*X
));
1400 for (k
= 0; k
< sbr
->kx
[0]; k
++) {
1401 for (i
= 0; i
< i_Temp
; i
++) {
1402 X
[0][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][0];
1403 X
[1][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][1];
1406 for (; k
< sbr
->kx
[0] + sbr
->m
[0]; k
++) {
1407 for (i
= 0; i
< i_Temp
; i
++) {
1408 X
[0][i
][k
] = Y0
[i
+ i_f
][k
][0];
1409 X
[1][i
][k
] = Y0
[i
+ i_f
][k
][1];
1413 for (k
= 0; k
< sbr
->kx
[1]; k
++) {
1414 for (i
= i_Temp
; i
< 38; i
++) {
1415 X
[0][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][0];
1416 X
[1][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][1];
1419 for (; k
< sbr
->kx
[1] + sbr
->m
[1]; k
++) {
1420 for (i
= i_Temp
; i
< i_f
; i
++) {
1421 X
[0][i
][k
] = Y1
[i
][k
][0];
1422 X
[1][i
][k
] = Y1
[i
][k
][1];
1428 /** High Frequency Adjustment (14496-3 sp04 p217) and Mapping
1429 * (14496-3 sp04 p217)
1431 static int sbr_mapping(AACContext
*ac
, SpectralBandReplication
*sbr
,
1432 SBRData
*ch_data
, int e_a
[2])
1436 memset(ch_data
->s_indexmapped
[1], 0, 7*sizeof(ch_data
->s_indexmapped
[1]));
1437 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1438 const unsigned int ilim
= sbr
->n
[ch_data
->bs_freq_res
[e
+ 1]];
1439 uint16_t *table
= ch_data
->bs_freq_res
[e
+ 1] ? sbr
->f_tablehigh
: sbr
->f_tablelow
;
1442 if (sbr
->kx
[1] != table
[0]) {
1443 av_log(ac
->avctx
, AV_LOG_ERROR
, "kx != f_table{high,low}[0]. "
1444 "Derived frequency tables were not regenerated.\n");
1448 for (i
= 0; i
< ilim
; i
++)
1449 for (m
= table
[i
]; m
< table
[i
+ 1]; m
++)
1450 sbr
->e_origmapped
[e
][m
- sbr
->kx
[1]] = ch_data
->env_facs
[e
+1][i
];
1452 // ch_data->bs_num_noise > 1 => 2 noise floors
1453 k
= (ch_data
->bs_num_noise
> 1) && (ch_data
->t_env
[e
] >= ch_data
->t_q
[1]);
1454 for (i
= 0; i
< sbr
->n_q
; i
++)
1455 for (m
= sbr
->f_tablenoise
[i
]; m
< sbr
->f_tablenoise
[i
+ 1]; m
++)
1456 sbr
->q_mapped
[e
][m
- sbr
->kx
[1]] = ch_data
->noise_facs
[k
+1][i
];
1458 for (i
= 0; i
< sbr
->n
[1]; i
++) {
1459 if (ch_data
->bs_add_harmonic_flag
) {
1460 const unsigned int m_midpoint
=
1461 (sbr
->f_tablehigh
[i
] + sbr
->f_tablehigh
[i
+ 1]) >> 1;
1463 ch_data
->s_indexmapped
[e
+ 1][m_midpoint
- sbr
->kx
[1]] = ch_data
->bs_add_harmonic
[i
] *
1464 (e
>= e_a
[1] || (ch_data
->s_indexmapped
[0][m_midpoint
- sbr
->kx
[1]] == 1));
1468 for (i
= 0; i
< ilim
; i
++) {
1469 int additional_sinusoid_present
= 0;
1470 for (m
= table
[i
]; m
< table
[i
+ 1]; m
++) {
1471 if (ch_data
->s_indexmapped
[e
+ 1][m
- sbr
->kx
[1]]) {
1472 additional_sinusoid_present
= 1;
1476 memset(&sbr
->s_mapped
[e
][table
[i
] - sbr
->kx
[1]], additional_sinusoid_present
,
1477 (table
[i
+ 1] - table
[i
]) * sizeof(sbr
->s_mapped
[e
][0]));
1481 memcpy(ch_data
->s_indexmapped
[0], ch_data
->s_indexmapped
[ch_data
->bs_num_env
], sizeof(ch_data
->s_indexmapped
[0]));
1485 /// Estimation of current envelope (14496-3 sp04 p218)
1486 static void sbr_env_estimate(float (*e_curr
)[48], float X_high
[64][40][2],
1487 SpectralBandReplication
*sbr
, SBRData
*ch_data
)
1490 int kx1
= sbr
->kx
[1];
1492 if (sbr
->bs_interpol_freq
) {
1493 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1494 const float recip_env_size
= 0.5f
/ (ch_data
->t_env
[e
+ 1] - ch_data
->t_env
[e
]);
1495 int ilb
= ch_data
->t_env
[e
] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1496 int iub
= ch_data
->t_env
[e
+ 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1498 for (m
= 0; m
< sbr
->m
[1]; m
++) {
1499 float sum
= sbr
->dsp
.sum_square(X_high
[m
+kx1
] + ilb
, iub
- ilb
);
1500 e_curr
[e
][m
] = sum
* recip_env_size
;
1506 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1507 const int env_size
= 2 * (ch_data
->t_env
[e
+ 1] - ch_data
->t_env
[e
]);
1508 int ilb
= ch_data
->t_env
[e
] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1509 int iub
= ch_data
->t_env
[e
+ 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1510 const uint16_t *table
= ch_data
->bs_freq_res
[e
+ 1] ? sbr
->f_tablehigh
: sbr
->f_tablelow
;
1512 for (p
= 0; p
< sbr
->n
[ch_data
->bs_freq_res
[e
+ 1]]; p
++) {
1514 const int den
= env_size
* (table
[p
+ 1] - table
[p
]);
1516 for (k
= table
[p
]; k
< table
[p
+ 1]; k
++) {
1517 sum
+= sbr
->dsp
.sum_square(X_high
[k
] + ilb
, iub
- ilb
);
1520 for (k
= table
[p
]; k
< table
[p
+ 1]; k
++) {
1521 e_curr
[e
][k
- kx1
] = sum
;
1529 * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
1530 * and Calculation of gain (14496-3 sp04 p219)
1532 static void sbr_gain_calc(AACContext
*ac
, SpectralBandReplication
*sbr
,
1533 SBRData
*ch_data
, const int e_a
[2])
1536 // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
1537 static const float limgain
[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
1539 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1540 int delta
= !((e
== e_a
[1]) || (e
== e_a
[0]));
1541 for (k
= 0; k
< sbr
->n_lim
; k
++) {
1542 float gain_boost
, gain_max
;
1543 float sum
[2] = { 0.0f
, 0.0f
};
1544 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1545 const float temp
= sbr
->e_origmapped
[e
][m
] / (1.0f
+ sbr
->q_mapped
[e
][m
]);
1546 sbr
->q_m
[e
][m
] = sqrtf(temp
* sbr
->q_mapped
[e
][m
]);
1547 sbr
->s_m
[e
][m
] = sqrtf(temp
* ch_data
->s_indexmapped
[e
+ 1][m
]);
1548 if (!sbr
->s_mapped
[e
][m
]) {
1549 sbr
->gain
[e
][m
] = sqrtf(sbr
->e_origmapped
[e
][m
] /
1550 ((1.0f
+ sbr
->e_curr
[e
][m
]) *
1551 (1.0f
+ sbr
->q_mapped
[e
][m
] * delta
)));
1553 sbr
->gain
[e
][m
] = sqrtf(sbr
->e_origmapped
[e
][m
] * sbr
->q_mapped
[e
][m
] /
1554 ((1.0f
+ sbr
->e_curr
[e
][m
]) *
1555 (1.0f
+ sbr
->q_mapped
[e
][m
])));
1558 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1559 sum
[0] += sbr
->e_origmapped
[e
][m
];
1560 sum
[1] += sbr
->e_curr
[e
][m
];
1562 gain_max
= limgain
[sbr
->bs_limiter_gains
] * sqrtf((FLT_EPSILON
+ sum
[0]) / (FLT_EPSILON
+ sum
[1]));
1563 gain_max
= FFMIN(100000.f
, gain_max
);
1564 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1565 float q_m_max
= sbr
->q_m
[e
][m
] * gain_max
/ sbr
->gain
[e
][m
];
1566 sbr
->q_m
[e
][m
] = FFMIN(sbr
->q_m
[e
][m
], q_m_max
);
1567 sbr
->gain
[e
][m
] = FFMIN(sbr
->gain
[e
][m
], gain_max
);
1569 sum
[0] = sum
[1] = 0.0f
;
1570 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1571 sum
[0] += sbr
->e_origmapped
[e
][m
];
1572 sum
[1] += sbr
->e_curr
[e
][m
] * sbr
->gain
[e
][m
] * sbr
->gain
[e
][m
]
1573 + sbr
->s_m
[e
][m
] * sbr
->s_m
[e
][m
]
1574 + (delta
&& !sbr
->s_m
[e
][m
]) * sbr
->q_m
[e
][m
] * sbr
->q_m
[e
][m
];
1576 gain_boost
= sqrtf((FLT_EPSILON
+ sum
[0]) / (FLT_EPSILON
+ sum
[1]));
1577 gain_boost
= FFMIN(1.584893192f
, gain_boost
);
1578 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1579 sbr
->gain
[e
][m
] *= gain_boost
;
1580 sbr
->q_m
[e
][m
] *= gain_boost
;
1581 sbr
->s_m
[e
][m
] *= gain_boost
;
1587 /// Assembling HF Signals (14496-3 sp04 p220)
1588 static void sbr_hf_assemble(float Y1
[38][64][2],
1589 const float X_high
[64][40][2],
1590 SpectralBandReplication
*sbr
, SBRData
*ch_data
,
1594 const int h_SL
= 4 * !sbr
->bs_smoothing_mode
;
1595 const int kx
= sbr
->kx
[1];
1596 const int m_max
= sbr
->m
[1];
1597 static const float h_smooth
[5] = {
1604 float (*g_temp
)[48] = ch_data
->g_temp
, (*q_temp
)[48] = ch_data
->q_temp
;
1605 int indexnoise
= ch_data
->f_indexnoise
;
1606 int indexsine
= ch_data
->f_indexsine
;
1609 for (i
= 0; i
< h_SL
; i
++) {
1610 memcpy(g_temp
[i
+ 2*ch_data
->t_env
[0]], sbr
->gain
[0], m_max
* sizeof(sbr
->gain
[0][0]));
1611 memcpy(q_temp
[i
+ 2*ch_data
->t_env
[0]], sbr
->q_m
[0], m_max
* sizeof(sbr
->q_m
[0][0]));
1614 memcpy(g_temp
[2*ch_data
->t_env
[0]], g_temp
[2*ch_data
->t_env_num_env_old
], 4*sizeof(g_temp
[0]));
1615 memcpy(q_temp
[2*ch_data
->t_env
[0]], q_temp
[2*ch_data
->t_env_num_env_old
], 4*sizeof(q_temp
[0]));
1618 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1619 for (i
= 2 * ch_data
->t_env
[e
]; i
< 2 * ch_data
->t_env
[e
+ 1]; i
++) {
1620 memcpy(g_temp
[h_SL
+ i
], sbr
->gain
[e
], m_max
* sizeof(sbr
->gain
[0][0]));
1621 memcpy(q_temp
[h_SL
+ i
], sbr
->q_m
[e
], m_max
* sizeof(sbr
->q_m
[0][0]));
1625 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1626 for (i
= 2 * ch_data
->t_env
[e
]; i
< 2 * ch_data
->t_env
[e
+ 1]; i
++) {
1627 LOCAL_ALIGNED_16(float, g_filt_tab
, [48]);
1628 LOCAL_ALIGNED_16(float, q_filt_tab
, [48]);
1629 float *g_filt
, *q_filt
;
1631 if (h_SL
&& e
!= e_a
[0] && e
!= e_a
[1]) {
1632 g_filt
= g_filt_tab
;
1633 q_filt
= q_filt_tab
;
1634 for (m
= 0; m
< m_max
; m
++) {
1635 const int idx1
= i
+ h_SL
;
1638 for (j
= 0; j
<= h_SL
; j
++) {
1639 g_filt
[m
] += g_temp
[idx1
- j
][m
] * h_smooth
[j
];
1640 q_filt
[m
] += q_temp
[idx1
- j
][m
] * h_smooth
[j
];
1644 g_filt
= g_temp
[i
+ h_SL
];
1648 sbr
->dsp
.hf_g_filt(Y1
[i
] + kx
, X_high
+ kx
, g_filt
, m_max
,
1649 i
+ ENVELOPE_ADJUSTMENT_OFFSET
);
1651 if (e
!= e_a
[0] && e
!= e_a
[1]) {
1652 sbr
->dsp
.hf_apply_noise
[indexsine
](Y1
[i
] + kx
, sbr
->s_m
[e
],
1656 int idx
= indexsine
&1;
1657 int A
= (1-((indexsine
+(kx
& 1))&2));
1658 int B
= (A
^(-idx
)) + idx
;
1659 float *out
= &Y1
[i
][kx
][idx
];
1660 float *in
= sbr
->s_m
[e
];
1661 for (m
= 0; m
+1 < m_max
; m
+=2) {
1662 out
[2*m
] += in
[m
] * A
;
1663 out
[2*m
+2] += in
[m
+1] * B
;
1666 out
[2*m
] += in
[m
] * A
;
1668 indexnoise
= (indexnoise
+ m_max
) & 0x1ff;
1669 indexsine
= (indexsine
+ 1) & 3;
1672 ch_data
->f_indexnoise
= indexnoise
;
1673 ch_data
->f_indexsine
= indexsine
;
1676 void ff_sbr_apply(AACContext
*ac
, SpectralBandReplication
*sbr
, int id_aac
,
1679 int downsampled
= ac
->oc
[1].m4ac
.ext_sample_rate
< sbr
->sample_rate
;
1681 int nch
= (id_aac
== TYPE_CPE
) ? 2 : 1;
1684 if (!sbr
->kx_and_m_pushed
) {
1685 sbr
->kx
[0] = sbr
->kx
[1];
1686 sbr
->m
[0] = sbr
->m
[1];
1688 sbr
->kx_and_m_pushed
= 0;
1692 sbr_dequant(sbr
, id_aac
);
1694 for (ch
= 0; ch
< nch
; ch
++) {
1695 /* decode channel */
1696 sbr_qmf_analysis(&ac
->fdsp
, &sbr
->mdct_ana
, &sbr
->dsp
, ch
? R
: L
, sbr
->data
[ch
].analysis_filterbank_samples
,
1697 (float*)sbr
->qmf_filter_scratch
,
1698 sbr
->data
[ch
].W
, sbr
->data
[ch
].Ypos
);
1699 sbr
->c
.sbr_lf_gen(ac
, sbr
, sbr
->X_low
,
1700 (const float (*)[32][32][2]) sbr
->data
[ch
].W
,
1701 sbr
->data
[ch
].Ypos
);
1702 sbr
->data
[ch
].Ypos
^= 1;
1704 sbr
->c
.sbr_hf_inverse_filter(&sbr
->dsp
, sbr
->alpha0
, sbr
->alpha1
,
1705 (const float (*)[40][2]) sbr
->X_low
, sbr
->k
[0]);
1706 sbr_chirp(sbr
, &sbr
->data
[ch
]);
1707 sbr_hf_gen(ac
, sbr
, sbr
->X_high
,
1708 (const float (*)[40][2]) sbr
->X_low
,
1709 (const float (*)[2]) sbr
->alpha0
,
1710 (const float (*)[2]) sbr
->alpha1
,
1711 sbr
->data
[ch
].bw_array
, sbr
->data
[ch
].t_env
,
1712 sbr
->data
[ch
].bs_num_env
);
1715 err
= sbr_mapping(ac
, sbr
, &sbr
->data
[ch
], sbr
->data
[ch
].e_a
);
1717 sbr_env_estimate(sbr
->e_curr
, sbr
->X_high
, sbr
, &sbr
->data
[ch
]);
1718 sbr_gain_calc(ac
, sbr
, &sbr
->data
[ch
], sbr
->data
[ch
].e_a
);
1719 sbr
->c
.sbr_hf_assemble(sbr
->data
[ch
].Y
[sbr
->data
[ch
].Ypos
],
1720 (const float (*)[40][2]) sbr
->X_high
,
1721 sbr
, &sbr
->data
[ch
],
1727 sbr
->c
.sbr_x_gen(sbr
, sbr
->X
[ch
],
1728 (const float (*)[64][2]) sbr
->data
[ch
].Y
[1-sbr
->data
[ch
].Ypos
],
1729 (const float (*)[64][2]) sbr
->data
[ch
].Y
[ sbr
->data
[ch
].Ypos
],
1730 (const float (*)[40][2]) sbr
->X_low
, ch
);
1733 if (ac
->oc
[1].m4ac
.ps
== 1) {
1734 if (sbr
->ps
.start
) {
1735 ff_ps_apply(ac
->avctx
, &sbr
->ps
, sbr
->X
[0], sbr
->X
[1], sbr
->kx
[1] + sbr
->m
[1]);
1737 memcpy(sbr
->X
[1], sbr
->X
[0], sizeof(sbr
->X
[0]));
1742 sbr_qmf_synthesis(&sbr
->mdct
, &sbr
->dsp
, &ac
->fdsp
,
1743 L
, sbr
->X
[0], sbr
->qmf_filter_scratch
,
1744 sbr
->data
[0].synthesis_filterbank_samples
,
1745 &sbr
->data
[0].synthesis_filterbank_samples_offset
,
1748 sbr_qmf_synthesis(&sbr
->mdct
, &sbr
->dsp
, &ac
->fdsp
,
1749 R
, sbr
->X
[1], sbr
->qmf_filter_scratch
,
1750 sbr
->data
[1].synthesis_filterbank_samples
,
1751 &sbr
->data
[1].synthesis_filterbank_samples_offset
,
1755 static void aacsbr_func_ptr_init(AACSBRContext
*c
)
1757 c
->sbr_lf_gen
= sbr_lf_gen
;
1758 c
->sbr_hf_assemble
= sbr_hf_assemble
;
1759 c
->sbr_x_gen
= sbr_x_gen
;
1760 c
->sbr_hf_inverse_filter
= sbr_hf_inverse_filter
;
1763 ff_aacsbr_func_ptr_init_mips(c
);