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"
38 #define ENVELOPE_ADJUSTMENT_OFFSET 2
39 #define NOISE_FLOOR_OFFSET 6.0f
47 T_HUFFMAN_ENV_BAL_1_5DB
,
48 F_HUFFMAN_ENV_BAL_1_5DB
,
51 T_HUFFMAN_ENV_BAL_3_0DB
,
52 F_HUFFMAN_ENV_BAL_3_0DB
,
53 T_HUFFMAN_NOISE_3_0DB
,
54 T_HUFFMAN_NOISE_BAL_3_0DB
,
58 * bs_frame_class - frame class of current SBR frame (14496-3 sp04 p98)
71 static VLC vlc_sbr
[10];
72 static const int8_t vlc_sbr_lav
[10] =
73 { 60, 60, 24, 24, 31, 31, 12, 12, 31, 12 };
74 static DECLARE_ALIGNED(16, float, analysis_cos_pre
)[64];
75 static DECLARE_ALIGNED(16, float, analysis_sin_pre
)[64];
76 static DECLARE_ALIGNED(16, float, analysis_cossin_post
)[32][2];
77 static const DECLARE_ALIGNED(16, float, zero64
)[64];
79 #define SBR_INIT_VLC_STATIC(num, size) \
80 INIT_VLC_STATIC(&vlc_sbr[num], 9, sbr_tmp[num].table_size / sbr_tmp[num].elem_size, \
81 sbr_tmp[num].sbr_bits , 1, 1, \
82 sbr_tmp[num].sbr_codes, sbr_tmp[num].elem_size, sbr_tmp[num].elem_size, \
85 #define SBR_VLC_ROW(name) \
86 { name ## _codes, name ## _bits, sizeof(name ## _codes), sizeof(name ## _codes[0]) }
88 av_cold
void ff_aac_sbr_init(void)
92 const void *sbr_codes
, *sbr_bits
;
93 const unsigned int table_size
, elem_size
;
95 SBR_VLC_ROW(t_huffman_env_1_5dB
),
96 SBR_VLC_ROW(f_huffman_env_1_5dB
),
97 SBR_VLC_ROW(t_huffman_env_bal_1_5dB
),
98 SBR_VLC_ROW(f_huffman_env_bal_1_5dB
),
99 SBR_VLC_ROW(t_huffman_env_3_0dB
),
100 SBR_VLC_ROW(f_huffman_env_3_0dB
),
101 SBR_VLC_ROW(t_huffman_env_bal_3_0dB
),
102 SBR_VLC_ROW(f_huffman_env_bal_3_0dB
),
103 SBR_VLC_ROW(t_huffman_noise_3_0dB
),
104 SBR_VLC_ROW(t_huffman_noise_bal_3_0dB
),
107 // SBR VLC table initialization
108 SBR_INIT_VLC_STATIC(0, 1098);
109 SBR_INIT_VLC_STATIC(1, 1092);
110 SBR_INIT_VLC_STATIC(2, 768);
111 SBR_INIT_VLC_STATIC(3, 1026);
112 SBR_INIT_VLC_STATIC(4, 1058);
113 SBR_INIT_VLC_STATIC(5, 1052);
114 SBR_INIT_VLC_STATIC(6, 544);
115 SBR_INIT_VLC_STATIC(7, 544);
116 SBR_INIT_VLC_STATIC(8, 592);
117 SBR_INIT_VLC_STATIC(9, 512);
119 for (n
= 0; n
< 64; n
++) {
120 float pre
= M_PI
* n
/ 64;
121 analysis_cos_pre
[n
] = cosf(pre
);
122 analysis_sin_pre
[n
] = sinf(pre
);
124 for (k
= 0; k
< 32; k
++) {
125 float post
= M_PI
* (k
+ 0.5) / 128;
126 analysis_cossin_post
[k
][0] = 4.0 * cosf(post
);
127 analysis_cossin_post
[k
][1] = -4.0 * sinf(post
);
129 for (n
= 1; n
< 320; n
++)
130 sbr_qmf_window_us
[320 + n
] = sbr_qmf_window_us
[320 - n
];
131 sbr_qmf_window_us
[384] = -sbr_qmf_window_us
[384];
132 sbr_qmf_window_us
[512] = -sbr_qmf_window_us
[512];
134 for (n
= 0; n
< 320; n
++)
135 sbr_qmf_window_ds
[n
] = sbr_qmf_window_us
[2*n
];
138 av_cold
void ff_aac_sbr_ctx_init(SpectralBandReplication
*sbr
)
140 sbr
->kx
[0] = sbr
->kx
[1] = 32; //Typo in spec, kx' inits to 32
141 sbr
->data
[0].e_a
[1] = sbr
->data
[1].e_a
[1] = -1;
142 sbr
->data
[0].synthesis_filterbank_samples_offset
= SBR_SYNTHESIS_BUF_SIZE
- (1280 - 128);
143 sbr
->data
[1].synthesis_filterbank_samples_offset
= SBR_SYNTHESIS_BUF_SIZE
- (1280 - 128);
144 ff_mdct_init(&sbr
->mdct
, 7, 1, 1.0/64);
145 ff_rdft_init(&sbr
->rdft
, 6, IDFT_R2C
);
148 av_cold
void ff_aac_sbr_ctx_close(SpectralBandReplication
*sbr
)
150 ff_mdct_end(&sbr
->mdct
);
151 ff_rdft_end(&sbr
->rdft
);
154 static int qsort_comparison_function_int16(const void *a
, const void *b
)
156 return *(const int16_t *)a
- *(const int16_t *)b
;
159 static inline int in_table_int16(const int16_t *table
, int last_el
, int16_t needle
)
162 for (i
= 0; i
<= last_el
; i
++)
163 if (table
[i
] == needle
)
168 /// Limiter Frequency Band Table (14496-3 sp04 p198)
169 static void sbr_make_f_tablelim(SpectralBandReplication
*sbr
)
172 if (sbr
->bs_limiter_bands
> 0) {
173 static const float bands_warped
[3] = { 1.32715174233856803909f
, //2^(0.49/1.2)
174 1.18509277094158210129f
, //2^(0.49/2)
175 1.11987160404675912501f
}; //2^(0.49/3)
176 const float lim_bands_per_octave_warped
= bands_warped
[sbr
->bs_limiter_bands
- 1];
177 int16_t patch_borders
[7];
178 uint16_t *in
= sbr
->f_tablelim
+ 1, *out
= sbr
->f_tablelim
;
180 patch_borders
[0] = sbr
->kx
[1];
181 for (k
= 1; k
<= sbr
->num_patches
; k
++)
182 patch_borders
[k
] = patch_borders
[k
-1] + sbr
->patch_num_subbands
[k
-1];
184 memcpy(sbr
->f_tablelim
, sbr
->f_tablelow
,
185 (sbr
->n
[0] + 1) * sizeof(sbr
->f_tablelow
[0]));
186 if (sbr
->num_patches
> 1)
187 memcpy(sbr
->f_tablelim
+ sbr
->n
[0] + 1, patch_borders
+ 1,
188 (sbr
->num_patches
- 1) * sizeof(patch_borders
[0]));
190 qsort(sbr
->f_tablelim
, sbr
->num_patches
+ sbr
->n
[0],
191 sizeof(sbr
->f_tablelim
[0]),
192 qsort_comparison_function_int16
);
194 sbr
->n_lim
= sbr
->n
[0] + sbr
->num_patches
- 1;
195 while (out
< sbr
->f_tablelim
+ sbr
->n_lim
) {
196 if (*in
>= *out
* lim_bands_per_octave_warped
) {
198 } else if (*in
== *out
||
199 !in_table_int16(patch_borders
, sbr
->num_patches
, *in
)) {
202 } else if (!in_table_int16(patch_borders
, sbr
->num_patches
, *out
)) {
210 sbr
->f_tablelim
[0] = sbr
->f_tablelow
[0];
211 sbr
->f_tablelim
[1] = sbr
->f_tablelow
[sbr
->n
[0]];
216 static unsigned int read_sbr_header(SpectralBandReplication
*sbr
, GetBitContext
*gb
)
218 unsigned int cnt
= get_bits_count(gb
);
219 uint8_t bs_header_extra_1
;
220 uint8_t bs_header_extra_2
;
221 int old_bs_limiter_bands
= sbr
->bs_limiter_bands
;
222 SpectrumParameters old_spectrum_params
;
226 // Save last spectrum parameters variables to compare to new ones
227 memcpy(&old_spectrum_params
, &sbr
->spectrum_params
, sizeof(SpectrumParameters
));
229 sbr
->bs_amp_res_header
= get_bits1(gb
);
230 sbr
->spectrum_params
.bs_start_freq
= get_bits(gb
, 4);
231 sbr
->spectrum_params
.bs_stop_freq
= get_bits(gb
, 4);
232 sbr
->spectrum_params
.bs_xover_band
= get_bits(gb
, 3);
233 skip_bits(gb
, 2); // bs_reserved
235 bs_header_extra_1
= get_bits1(gb
);
236 bs_header_extra_2
= get_bits1(gb
);
238 if (bs_header_extra_1
) {
239 sbr
->spectrum_params
.bs_freq_scale
= get_bits(gb
, 2);
240 sbr
->spectrum_params
.bs_alter_scale
= get_bits1(gb
);
241 sbr
->spectrum_params
.bs_noise_bands
= get_bits(gb
, 2);
243 sbr
->spectrum_params
.bs_freq_scale
= 2;
244 sbr
->spectrum_params
.bs_alter_scale
= 1;
245 sbr
->spectrum_params
.bs_noise_bands
= 2;
248 // Check if spectrum parameters changed
249 if (memcmp(&old_spectrum_params
, &sbr
->spectrum_params
, sizeof(SpectrumParameters
)))
252 if (bs_header_extra_2
) {
253 sbr
->bs_limiter_bands
= get_bits(gb
, 2);
254 sbr
->bs_limiter_gains
= get_bits(gb
, 2);
255 sbr
->bs_interpol_freq
= get_bits1(gb
);
256 sbr
->bs_smoothing_mode
= get_bits1(gb
);
258 sbr
->bs_limiter_bands
= 2;
259 sbr
->bs_limiter_gains
= 2;
260 sbr
->bs_interpol_freq
= 1;
261 sbr
->bs_smoothing_mode
= 1;
264 if (sbr
->bs_limiter_bands
!= old_bs_limiter_bands
&& !sbr
->reset
)
265 sbr_make_f_tablelim(sbr
);
267 return get_bits_count(gb
) - cnt
;
270 static int array_min_int16(const int16_t *array
, int nel
)
272 int i
, min
= array
[0];
273 for (i
= 1; i
< nel
; i
++)
274 min
= FFMIN(array
[i
], min
);
278 static void make_bands(int16_t* bands
, int start
, int stop
, int num_bands
)
280 int k
, previous
, present
;
283 base
= powf((float)stop
/ start
, 1.0f
/ num_bands
);
287 for (k
= 0; k
< num_bands
-1; k
++) {
289 present
= lrintf(prod
);
290 bands
[k
] = present
- previous
;
293 bands
[num_bands
-1] = stop
- previous
;
296 static int check_n_master(AVCodecContext
*avccontext
, int n_master
, int bs_xover_band
)
298 // Requirements (14496-3 sp04 p205)
300 av_log(avccontext
, AV_LOG_ERROR
, "Invalid n_master: %d\n", n_master
);
303 if (bs_xover_band
>= n_master
) {
304 av_log(avccontext
, AV_LOG_ERROR
,
305 "Invalid bitstream, crossover band index beyond array bounds: %d\n",
312 /// Master Frequency Band Table (14496-3 sp04 p194)
313 static int sbr_make_f_master(AACContext
*ac
, SpectralBandReplication
*sbr
,
314 SpectrumParameters
*spectrum
)
316 unsigned int temp
, max_qmf_subbands
;
317 unsigned int start_min
, stop_min
;
319 const int8_t *sbr_offset_ptr
;
322 if (sbr
->sample_rate
< 32000) {
324 } else if (sbr
->sample_rate
< 64000) {
329 start_min
= ((temp
<< 7) + (sbr
->sample_rate
>> 1)) / sbr
->sample_rate
;
330 stop_min
= ((temp
<< 8) + (sbr
->sample_rate
>> 1)) / sbr
->sample_rate
;
332 switch (sbr
->sample_rate
) {
334 sbr_offset_ptr
= sbr_offset
[0];
337 sbr_offset_ptr
= sbr_offset
[1];
340 sbr_offset_ptr
= sbr_offset
[2];
343 sbr_offset_ptr
= sbr_offset
[3];
345 case 44100: case 48000: case 64000:
346 sbr_offset_ptr
= sbr_offset
[4];
348 case 88200: case 96000: case 128000: case 176400: case 192000:
349 sbr_offset_ptr
= sbr_offset
[5];
352 av_log(ac
->avccontext
, AV_LOG_ERROR
,
353 "Unsupported sample rate for SBR: %d\n", sbr
->sample_rate
);
357 sbr
->k
[0] = start_min
+ sbr_offset_ptr
[spectrum
->bs_start_freq
];
359 if (spectrum
->bs_stop_freq
< 14) {
360 sbr
->k
[2] = stop_min
;
361 make_bands(stop_dk
, stop_min
, 64, 13);
362 qsort(stop_dk
, 13, sizeof(stop_dk
[0]), qsort_comparison_function_int16
);
363 for (k
= 0; k
< spectrum
->bs_stop_freq
; k
++)
364 sbr
->k
[2] += stop_dk
[k
];
365 } else if (spectrum
->bs_stop_freq
== 14) {
366 sbr
->k
[2] = 2*sbr
->k
[0];
367 } else if (spectrum
->bs_stop_freq
== 15) {
368 sbr
->k
[2] = 3*sbr
->k
[0];
370 av_log(ac
->avccontext
, AV_LOG_ERROR
,
371 "Invalid bs_stop_freq: %d\n", spectrum
->bs_stop_freq
);
374 sbr
->k
[2] = FFMIN(64, sbr
->k
[2]);
376 // Requirements (14496-3 sp04 p205)
377 if (sbr
->sample_rate
<= 32000) {
378 max_qmf_subbands
= 48;
379 } else if (sbr
->sample_rate
== 44100) {
380 max_qmf_subbands
= 35;
381 } else if (sbr
->sample_rate
>= 48000)
382 max_qmf_subbands
= 32;
384 if (sbr
->k
[2] - sbr
->k
[0] > max_qmf_subbands
) {
385 av_log(ac
->avccontext
, AV_LOG_ERROR
,
386 "Invalid bitstream, too many QMF subbands: %d\n", sbr
->k
[2] - sbr
->k
[0]);
390 if (!spectrum
->bs_freq_scale
) {
394 dk
= spectrum
->bs_alter_scale
+ 1;
395 sbr
->n_master
= ((sbr
->k
[2] - sbr
->k
[0] + (dk
&2)) >> dk
) << 1;
396 if (check_n_master(ac
->avccontext
, sbr
->n_master
, sbr
->spectrum_params
.bs_xover_band
))
399 for (k
= 1; k
<= sbr
->n_master
; k
++)
400 sbr
->f_master
[k
] = dk
;
402 k2diff
= sbr
->k
[2] - sbr
->k
[0] - sbr
->n_master
* dk
;
405 sbr
->f_master
[2]-= (k2diff
< 1);
407 sbr
->f_master
[sbr
->n_master
]++;
410 sbr
->f_master
[0] = sbr
->k
[0];
411 for (k
= 1; k
<= sbr
->n_master
; k
++)
412 sbr
->f_master
[k
] += sbr
->f_master
[k
- 1];
415 int half_bands
= 7 - spectrum
->bs_freq_scale
; // bs_freq_scale = {1,2,3}
416 int two_regions
, num_bands_0
;
417 int vdk0_max
, vdk1_min
;
420 if (49 * sbr
->k
[2] > 110 * sbr
->k
[0]) {
422 sbr
->k
[1] = 2 * sbr
->k
[0];
425 sbr
->k
[1] = sbr
->k
[2];
428 num_bands_0
= lrintf(half_bands
* log2f(sbr
->k
[1] / (float)sbr
->k
[0])) * 2;
430 if (num_bands_0
<= 0) { // Requirements (14496-3 sp04 p205)
431 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Invalid num_bands_0: %d\n", num_bands_0
);
437 make_bands(vk0
+1, sbr
->k
[0], sbr
->k
[1], num_bands_0
);
439 qsort(vk0
+ 1, num_bands_0
, sizeof(vk0
[1]), qsort_comparison_function_int16
);
440 vdk0_max
= vk0
[num_bands_0
];
443 for (k
= 1; k
<= num_bands_0
; k
++) {
444 if (vk0
[k
] <= 0) { // Requirements (14496-3 sp04 p205)
445 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Invalid vDk0[%d]: %d\n", k
, vk0
[k
]);
453 float invwarp
= spectrum
->bs_alter_scale
? 0.76923076923076923077f
454 : 1.0f
; // bs_alter_scale = {0,1}
455 int num_bands_1
= lrintf(half_bands
* invwarp
*
456 log2f(sbr
->k
[2] / (float)sbr
->k
[1])) * 2;
458 make_bands(vk1
+1, sbr
->k
[1], sbr
->k
[2], num_bands_1
);
460 vdk1_min
= array_min_int16(vk1
+ 1, num_bands_1
);
462 if (vdk1_min
< vdk0_max
) {
464 qsort(vk1
+ 1, num_bands_1
, sizeof(vk1
[1]), qsort_comparison_function_int16
);
465 change
= FFMIN(vdk0_max
- vk1
[1], (vk1
[num_bands_1
] - vk1
[1]) >> 1);
467 vk1
[num_bands_1
] -= change
;
470 qsort(vk1
+ 1, num_bands_1
, sizeof(vk1
[1]), qsort_comparison_function_int16
);
473 for (k
= 1; k
<= num_bands_1
; k
++) {
474 if (vk1
[k
] <= 0) { // Requirements (14496-3 sp04 p205)
475 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Invalid vDk1[%d]: %d\n", k
, vk1
[k
]);
481 sbr
->n_master
= num_bands_0
+ num_bands_1
;
482 if (check_n_master(ac
->avccontext
, sbr
->n_master
, sbr
->spectrum_params
.bs_xover_band
))
484 memcpy(&sbr
->f_master
[0], vk0
,
485 (num_bands_0
+ 1) * sizeof(sbr
->f_master
[0]));
486 memcpy(&sbr
->f_master
[num_bands_0
+ 1], vk1
+ 1,
487 num_bands_1
* sizeof(sbr
->f_master
[0]));
490 sbr
->n_master
= num_bands_0
;
491 if (check_n_master(ac
->avccontext
, sbr
->n_master
, sbr
->spectrum_params
.bs_xover_band
))
493 memcpy(sbr
->f_master
, vk0
, (num_bands_0
+ 1) * sizeof(sbr
->f_master
[0]));
500 /// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
501 static int sbr_hf_calc_npatches(AACContext
*ac
, SpectralBandReplication
*sbr
)
505 int usb
= sbr
->kx
[1];
506 int goal_sb
= ((1000 << 11) + (sbr
->sample_rate
>> 1)) / sbr
->sample_rate
;
508 sbr
->num_patches
= 0;
510 if (goal_sb
< sbr
->kx
[1] + sbr
->m
[1]) {
511 for (k
= 0; sbr
->f_master
[k
] < goal_sb
; k
++) ;
517 for (i
= k
; i
== k
|| sb
> (sbr
->k
[0] - 1 + msb
- odd
); i
--) {
518 sb
= sbr
->f_master
[i
];
519 odd
= (sb
+ sbr
->k
[0]) & 1;
522 // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
523 // After this check the final number of patches can still be six which is
524 // illegal however the Coding Technologies decoder check stream has a final
525 // count of 6 patches
526 if (sbr
->num_patches
> 5) {
527 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Too many patches: %d\n", sbr
->num_patches
);
531 sbr
->patch_num_subbands
[sbr
->num_patches
] = FFMAX(sb
- usb
, 0);
532 sbr
->patch_start_subband
[sbr
->num_patches
] = sbr
->k
[0] - odd
- sbr
->patch_num_subbands
[sbr
->num_patches
];
534 if (sbr
->patch_num_subbands
[sbr
->num_patches
] > 0) {
541 if (sbr
->f_master
[k
] - sb
< 3)
543 } while (sb
!= sbr
->kx
[1] + sbr
->m
[1]);
545 if (sbr
->patch_num_subbands
[sbr
->num_patches
-1] < 3 && sbr
->num_patches
> 1)
551 /// Derived Frequency Band Tables (14496-3 sp04 p197)
552 static int sbr_make_f_derived(AACContext
*ac
, SpectralBandReplication
*sbr
)
556 sbr
->n
[1] = sbr
->n_master
- sbr
->spectrum_params
.bs_xover_band
;
557 sbr
->n
[0] = (sbr
->n
[1] + 1) >> 1;
559 memcpy(sbr
->f_tablehigh
, &sbr
->f_master
[sbr
->spectrum_params
.bs_xover_band
],
560 (sbr
->n
[1] + 1) * sizeof(sbr
->f_master
[0]));
561 sbr
->m
[1] = sbr
->f_tablehigh
[sbr
->n
[1]] - sbr
->f_tablehigh
[0];
562 sbr
->kx
[1] = sbr
->f_tablehigh
[0];
564 // Requirements (14496-3 sp04 p205)
565 if (sbr
->kx
[1] + sbr
->m
[1] > 64) {
566 av_log(ac
->avccontext
, AV_LOG_ERROR
,
567 "Stop frequency border too high: %d\n", sbr
->kx
[1] + sbr
->m
[1]);
570 if (sbr
->kx
[1] > 32) {
571 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Start frequency border too high: %d\n", sbr
->kx
[1]);
575 sbr
->f_tablelow
[0] = sbr
->f_tablehigh
[0];
576 temp
= sbr
->n
[1] & 1;
577 for (k
= 1; k
<= sbr
->n
[0]; k
++)
578 sbr
->f_tablelow
[k
] = sbr
->f_tablehigh
[2 * k
- temp
];
580 sbr
->n_q
= FFMAX(1, lrintf(sbr
->spectrum_params
.bs_noise_bands
*
581 log2f(sbr
->k
[2] / (float)sbr
->kx
[1]))); // 0 <= bs_noise_bands <= 3
583 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Too many noise floor scale factors: %d\n", sbr
->n_q
);
587 sbr
->f_tablenoise
[0] = sbr
->f_tablelow
[0];
589 for (k
= 1; k
<= sbr
->n_q
; k
++) {
590 temp
+= (sbr
->n
[0] - temp
) / (sbr
->n_q
+ 1 - k
);
591 sbr
->f_tablenoise
[k
] = sbr
->f_tablelow
[temp
];
594 if (sbr_hf_calc_npatches(ac
, sbr
) < 0)
597 sbr_make_f_tablelim(sbr
);
599 sbr
->data
[0].f_indexnoise
= 0;
600 sbr
->data
[1].f_indexnoise
= 0;
605 static av_always_inline
void get_bits1_vector(GetBitContext
*gb
, uint8_t *vec
,
609 for (i
= 0; i
< elements
; i
++) {
610 vec
[i
] = get_bits1(gb
);
614 /** ceil(log2(index+1)) */
615 static const int8_t ceil_log2
[] = {
619 static int read_sbr_grid(AACContext
*ac
, SpectralBandReplication
*sbr
,
620 GetBitContext
*gb
, SBRData
*ch_data
)
623 unsigned bs_pointer
= 0;
624 // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
625 int abs_bord_trail
= 16;
626 int num_rel_lead
, num_rel_trail
;
627 unsigned bs_num_env_old
= ch_data
->bs_num_env
;
629 ch_data
->bs_freq_res
[0] = ch_data
->bs_freq_res
[ch_data
->bs_num_env
];
630 ch_data
->bs_amp_res
= sbr
->bs_amp_res_header
;
631 ch_data
->t_env_num_env_old
= ch_data
->t_env
[bs_num_env_old
];
633 switch (ch_data
->bs_frame_class
= get_bits(gb
, 2)) {
635 ch_data
->bs_num_env
= 1 << get_bits(gb
, 2);
636 num_rel_lead
= ch_data
->bs_num_env
- 1;
637 if (ch_data
->bs_num_env
== 1)
638 ch_data
->bs_amp_res
= 0;
640 if (ch_data
->bs_num_env
> 4) {
641 av_log(ac
->avccontext
, AV_LOG_ERROR
,
642 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
643 ch_data
->bs_num_env
);
647 ch_data
->t_env
[0] = 0;
648 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
650 abs_bord_trail
= (abs_bord_trail
+ (ch_data
->bs_num_env
>> 1)) /
652 for (i
= 0; i
< num_rel_lead
; i
++)
653 ch_data
->t_env
[i
+ 1] = ch_data
->t_env
[i
] + abs_bord_trail
;
655 ch_data
->bs_freq_res
[1] = get_bits1(gb
);
656 for (i
= 1; i
< ch_data
->bs_num_env
; i
++)
657 ch_data
->bs_freq_res
[i
+ 1] = ch_data
->bs_freq_res
[1];
660 abs_bord_trail
+= get_bits(gb
, 2);
661 num_rel_trail
= get_bits(gb
, 2);
662 ch_data
->bs_num_env
= num_rel_trail
+ 1;
663 ch_data
->t_env
[0] = 0;
664 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
666 for (i
= 0; i
< num_rel_trail
; i
++)
667 ch_data
->t_env
[ch_data
->bs_num_env
- 1 - i
] =
668 ch_data
->t_env
[ch_data
->bs_num_env
- i
] - 2 * get_bits(gb
, 2) - 2;
670 bs_pointer
= get_bits(gb
, ceil_log2
[ch_data
->bs_num_env
]);
672 for (i
= 0; i
< ch_data
->bs_num_env
; i
++)
673 ch_data
->bs_freq_res
[ch_data
->bs_num_env
- i
] = get_bits1(gb
);
676 ch_data
->t_env
[0] = get_bits(gb
, 2);
677 num_rel_lead
= get_bits(gb
, 2);
678 ch_data
->bs_num_env
= num_rel_lead
+ 1;
679 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
681 for (i
= 0; i
< num_rel_lead
; i
++)
682 ch_data
->t_env
[i
+ 1] = ch_data
->t_env
[i
] + 2 * get_bits(gb
, 2) + 2;
684 bs_pointer
= get_bits(gb
, ceil_log2
[ch_data
->bs_num_env
]);
686 get_bits1_vector(gb
, ch_data
->bs_freq_res
+ 1, ch_data
->bs_num_env
);
689 ch_data
->t_env
[0] = get_bits(gb
, 2);
690 abs_bord_trail
+= get_bits(gb
, 2);
691 num_rel_lead
= get_bits(gb
, 2);
692 num_rel_trail
= get_bits(gb
, 2);
693 ch_data
->bs_num_env
= num_rel_lead
+ num_rel_trail
+ 1;
695 if (ch_data
->bs_num_env
> 5) {
696 av_log(ac
->avccontext
, AV_LOG_ERROR
,
697 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
698 ch_data
->bs_num_env
);
702 ch_data
->t_env
[ch_data
->bs_num_env
] = abs_bord_trail
;
704 for (i
= 0; i
< num_rel_lead
; i
++)
705 ch_data
->t_env
[i
+ 1] = ch_data
->t_env
[i
] + 2 * get_bits(gb
, 2) + 2;
706 for (i
= 0; i
< num_rel_trail
; i
++)
707 ch_data
->t_env
[ch_data
->bs_num_env
- 1 - i
] =
708 ch_data
->t_env
[ch_data
->bs_num_env
- i
] - 2 * get_bits(gb
, 2) - 2;
710 bs_pointer
= get_bits(gb
, ceil_log2
[ch_data
->bs_num_env
]);
712 get_bits1_vector(gb
, ch_data
->bs_freq_res
+ 1, ch_data
->bs_num_env
);
716 if (bs_pointer
> ch_data
->bs_num_env
+ 1) {
717 av_log(ac
->avccontext
, AV_LOG_ERROR
,
718 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
723 for (i
= 1; i
<= ch_data
->bs_num_env
; i
++) {
724 if (ch_data
->t_env
[i
-1] > ch_data
->t_env
[i
]) {
725 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Non monotone time borders\n");
730 ch_data
->bs_num_noise
= (ch_data
->bs_num_env
> 1) + 1;
732 ch_data
->t_q
[0] = ch_data
->t_env
[0];
733 ch_data
->t_q
[ch_data
->bs_num_noise
] = ch_data
->t_env
[ch_data
->bs_num_env
];
734 if (ch_data
->bs_num_noise
> 1) {
736 if (ch_data
->bs_frame_class
== FIXFIX
) {
737 idx
= ch_data
->bs_num_env
>> 1;
738 } else if (ch_data
->bs_frame_class
& 1) { // FIXVAR or VARVAR
739 idx
= ch_data
->bs_num_env
- FFMAX(bs_pointer
- 1, 1);
743 else if (bs_pointer
== 1)
744 idx
= ch_data
->bs_num_env
- 1;
745 else // bs_pointer > 1
746 idx
= bs_pointer
- 1;
748 ch_data
->t_q
[1] = ch_data
->t_env
[idx
];
751 ch_data
->e_a
[0] = -(ch_data
->e_a
[1] != bs_num_env_old
); // l_APrev
752 ch_data
->e_a
[1] = -1;
753 if ((ch_data
->bs_frame_class
& 1) && bs_pointer
) { // FIXVAR or VARVAR and bs_pointer != 0
754 ch_data
->e_a
[1] = ch_data
->bs_num_env
+ 1 - bs_pointer
;
755 } else if ((ch_data
->bs_frame_class
== 2) && (bs_pointer
> 1)) // VARFIX and bs_pointer > 1
756 ch_data
->e_a
[1] = bs_pointer
- 1;
761 static void copy_sbr_grid(SBRData
*dst
, const SBRData
*src
) {
762 //These variables are saved from the previous frame rather than copied
763 dst
->bs_freq_res
[0] = dst
->bs_freq_res
[dst
->bs_num_env
];
764 dst
->t_env_num_env_old
= dst
->t_env
[dst
->bs_num_env
];
765 dst
->e_a
[0] = -(dst
->e_a
[1] != dst
->bs_num_env
);
767 //These variables are read from the bitstream and therefore copied
768 memcpy(dst
->bs_freq_res
+1, src
->bs_freq_res
+1, sizeof(dst
->bs_freq_res
)-sizeof(*dst
->bs_freq_res
));
769 memcpy(dst
->t_env
, src
->t_env
, sizeof(dst
->t_env
));
770 memcpy(dst
->t_q
, src
->t_q
, sizeof(dst
->t_q
));
771 dst
->bs_num_env
= src
->bs_num_env
;
772 dst
->bs_amp_res
= src
->bs_amp_res
;
773 dst
->bs_num_noise
= src
->bs_num_noise
;
774 dst
->bs_frame_class
= src
->bs_frame_class
;
775 dst
->e_a
[1] = src
->e_a
[1];
778 /// Read how the envelope and noise floor data is delta coded
779 static void read_sbr_dtdf(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
782 get_bits1_vector(gb
, ch_data
->bs_df_env
, ch_data
->bs_num_env
);
783 get_bits1_vector(gb
, ch_data
->bs_df_noise
, ch_data
->bs_num_noise
);
786 /// Read inverse filtering data
787 static void read_sbr_invf(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
792 memcpy(ch_data
->bs_invf_mode
[1], ch_data
->bs_invf_mode
[0], 5 * sizeof(uint8_t));
793 for (i
= 0; i
< sbr
->n_q
; i
++)
794 ch_data
->bs_invf_mode
[0][i
] = get_bits(gb
, 2);
797 static void read_sbr_envelope(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
798 SBRData
*ch_data
, int ch
)
802 VLC_TYPE (*t_huff
)[2], (*f_huff
)[2];
804 const int delta
= (ch
== 1 && sbr
->bs_coupling
== 1) + 1;
805 const int odd
= sbr
->n
[1] & 1;
807 if (sbr
->bs_coupling
&& ch
) {
808 if (ch_data
->bs_amp_res
) {
810 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_BAL_3_0DB
].table
;
811 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_BAL_3_0DB
];
812 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_BAL_3_0DB
].table
;
813 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_BAL_3_0DB
];
816 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_BAL_1_5DB
].table
;
817 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_BAL_1_5DB
];
818 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_BAL_1_5DB
].table
;
819 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_BAL_1_5DB
];
822 if (ch_data
->bs_amp_res
) {
824 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_3_0DB
].table
;
825 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_3_0DB
];
826 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_3_0DB
].table
;
827 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_3_0DB
];
830 t_huff
= vlc_sbr
[T_HUFFMAN_ENV_1_5DB
].table
;
831 t_lav
= vlc_sbr_lav
[T_HUFFMAN_ENV_1_5DB
];
832 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_1_5DB
].table
;
833 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_1_5DB
];
837 for (i
= 0; i
< ch_data
->bs_num_env
; i
++) {
838 if (ch_data
->bs_df_env
[i
]) {
839 // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
840 if (ch_data
->bs_freq_res
[i
+ 1] == ch_data
->bs_freq_res
[i
]) {
841 for (j
= 0; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++)
842 ch_data
->env_facs
[i
+ 1][j
] = ch_data
->env_facs
[i
][j
] + delta
* (get_vlc2(gb
, t_huff
, 9, 3) - t_lav
);
843 } else if (ch_data
->bs_freq_res
[i
+ 1]) {
844 for (j
= 0; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++) {
845 k
= (j
+ odd
) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
846 ch_data
->env_facs
[i
+ 1][j
] = ch_data
->env_facs
[i
][k
] + delta
* (get_vlc2(gb
, t_huff
, 9, 3) - t_lav
);
849 for (j
= 0; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++) {
850 k
= j
? 2*j
- odd
: 0; // find k such that f_tablehigh[k] == f_tablelow[j]
851 ch_data
->env_facs
[i
+ 1][j
] = ch_data
->env_facs
[i
][k
] + delta
* (get_vlc2(gb
, t_huff
, 9, 3) - t_lav
);
855 ch_data
->env_facs
[i
+ 1][0] = delta
* get_bits(gb
, bits
); // bs_env_start_value_balance
856 for (j
= 1; j
< sbr
->n
[ch_data
->bs_freq_res
[i
+ 1]]; j
++)
857 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
);
861 //assign 0th elements of env_facs from last elements
862 memcpy(ch_data
->env_facs
[0], ch_data
->env_facs
[ch_data
->bs_num_env
],
863 sizeof(ch_data
->env_facs
[0]));
866 static void read_sbr_noise(SpectralBandReplication
*sbr
, GetBitContext
*gb
,
867 SBRData
*ch_data
, int ch
)
870 VLC_TYPE (*t_huff
)[2], (*f_huff
)[2];
872 int delta
= (ch
== 1 && sbr
->bs_coupling
== 1) + 1;
874 if (sbr
->bs_coupling
&& ch
) {
875 t_huff
= vlc_sbr
[T_HUFFMAN_NOISE_BAL_3_0DB
].table
;
876 t_lav
= vlc_sbr_lav
[T_HUFFMAN_NOISE_BAL_3_0DB
];
877 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_BAL_3_0DB
].table
;
878 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_BAL_3_0DB
];
880 t_huff
= vlc_sbr
[T_HUFFMAN_NOISE_3_0DB
].table
;
881 t_lav
= vlc_sbr_lav
[T_HUFFMAN_NOISE_3_0DB
];
882 f_huff
= vlc_sbr
[F_HUFFMAN_ENV_3_0DB
].table
;
883 f_lav
= vlc_sbr_lav
[F_HUFFMAN_ENV_3_0DB
];
886 for (i
= 0; i
< ch_data
->bs_num_noise
; i
++) {
887 if (ch_data
->bs_df_noise
[i
]) {
888 for (j
= 0; j
< sbr
->n_q
; j
++)
889 ch_data
->noise_facs
[i
+ 1][j
] = ch_data
->noise_facs
[i
][j
] + delta
* (get_vlc2(gb
, t_huff
, 9, 2) - t_lav
);
891 ch_data
->noise_facs
[i
+ 1][0] = delta
* get_bits(gb
, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
892 for (j
= 1; j
< sbr
->n_q
; j
++)
893 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
);
897 //assign 0th elements of noise_facs from last elements
898 memcpy(ch_data
->noise_facs
[0], ch_data
->noise_facs
[ch_data
->bs_num_noise
],
899 sizeof(ch_data
->noise_facs
[0]));
902 static void read_sbr_extension(AACContext
*ac
, SpectralBandReplication
*sbr
,
904 int bs_extension_id
, int *num_bits_left
)
906 //TODO - implement ps_data for parametric stereo parsing
907 switch (bs_extension_id
) {
908 case EXTENSION_ID_PS
:
910 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
911 skip_bits_long(gb
, *num_bits_left
); // bs_fill_bits
915 *num_bits_left
-= ff_ps_data(gb
, ps
);
917 av_log_missing_feature(ac
->avccontext
, "Parametric Stereo is", 0);
918 skip_bits_long(gb
, *num_bits_left
); // bs_fill_bits
924 av_log_missing_feature(ac
->avccontext
, "Reserved SBR extensions are", 1);
925 skip_bits_long(gb
, *num_bits_left
); // bs_fill_bits
931 static int read_sbr_single_channel_element(AACContext
*ac
,
932 SpectralBandReplication
*sbr
,
935 if (get_bits1(gb
)) // bs_data_extra
936 skip_bits(gb
, 4); // bs_reserved
938 if (read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[0]))
940 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[0]);
941 read_sbr_invf(sbr
, gb
, &sbr
->data
[0]);
942 read_sbr_envelope(sbr
, gb
, &sbr
->data
[0], 0);
943 read_sbr_noise(sbr
, gb
, &sbr
->data
[0], 0);
945 if ((sbr
->data
[0].bs_add_harmonic_flag
= get_bits1(gb
)))
946 get_bits1_vector(gb
, sbr
->data
[0].bs_add_harmonic
, sbr
->n
[1]);
951 static int read_sbr_channel_pair_element(AACContext
*ac
,
952 SpectralBandReplication
*sbr
,
955 if (get_bits1(gb
)) // bs_data_extra
956 skip_bits(gb
, 8); // bs_reserved
958 if ((sbr
->bs_coupling
= get_bits1(gb
))) {
959 if (read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[0]))
961 copy_sbr_grid(&sbr
->data
[1], &sbr
->data
[0]);
962 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[0]);
963 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[1]);
964 read_sbr_invf(sbr
, gb
, &sbr
->data
[0]);
965 memcpy(sbr
->data
[1].bs_invf_mode
[1], sbr
->data
[1].bs_invf_mode
[0], sizeof(sbr
->data
[1].bs_invf_mode
[0]));
966 memcpy(sbr
->data
[1].bs_invf_mode
[0], sbr
->data
[0].bs_invf_mode
[0], sizeof(sbr
->data
[1].bs_invf_mode
[0]));
967 read_sbr_envelope(sbr
, gb
, &sbr
->data
[0], 0);
968 read_sbr_noise(sbr
, gb
, &sbr
->data
[0], 0);
969 read_sbr_envelope(sbr
, gb
, &sbr
->data
[1], 1);
970 read_sbr_noise(sbr
, gb
, &sbr
->data
[1], 1);
972 if (read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[0]) ||
973 read_sbr_grid(ac
, sbr
, gb
, &sbr
->data
[1]))
975 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[0]);
976 read_sbr_dtdf(sbr
, gb
, &sbr
->data
[1]);
977 read_sbr_invf(sbr
, gb
, &sbr
->data
[0]);
978 read_sbr_invf(sbr
, gb
, &sbr
->data
[1]);
979 read_sbr_envelope(sbr
, gb
, &sbr
->data
[0], 0);
980 read_sbr_envelope(sbr
, gb
, &sbr
->data
[1], 1);
981 read_sbr_noise(sbr
, gb
, &sbr
->data
[0], 0);
982 read_sbr_noise(sbr
, gb
, &sbr
->data
[1], 1);
985 if ((sbr
->data
[0].bs_add_harmonic_flag
= get_bits1(gb
)))
986 get_bits1_vector(gb
, sbr
->data
[0].bs_add_harmonic
, sbr
->n
[1]);
987 if ((sbr
->data
[1].bs_add_harmonic_flag
= get_bits1(gb
)))
988 get_bits1_vector(gb
, sbr
->data
[1].bs_add_harmonic
, sbr
->n
[1]);
993 static unsigned int read_sbr_data(AACContext
*ac
, SpectralBandReplication
*sbr
,
994 GetBitContext
*gb
, int id_aac
)
996 unsigned int cnt
= get_bits_count(gb
);
998 if (id_aac
== TYPE_SCE
|| id_aac
== TYPE_CCE
) {
999 if (read_sbr_single_channel_element(ac
, sbr
, gb
)) {
1001 return get_bits_count(gb
) - cnt
;
1003 } else if (id_aac
== TYPE_CPE
) {
1004 if (read_sbr_channel_pair_element(ac
, sbr
, gb
)) {
1006 return get_bits_count(gb
) - cnt
;
1009 av_log(ac
->avccontext
, AV_LOG_ERROR
,
1010 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac
);
1012 return get_bits_count(gb
) - cnt
;
1014 if (get_bits1(gb
)) { // bs_extended_data
1015 int num_bits_left
= get_bits(gb
, 4); // bs_extension_size
1016 if (num_bits_left
== 15)
1017 num_bits_left
+= get_bits(gb
, 8); // bs_esc_count
1019 num_bits_left
<<= 3;
1020 while (num_bits_left
> 7) {
1022 read_sbr_extension(ac
, sbr
, gb
, get_bits(gb
, 2), &num_bits_left
); // bs_extension_id
1026 return get_bits_count(gb
) - cnt
;
1029 static void sbr_reset(AACContext
*ac
, SpectralBandReplication
*sbr
)
1032 err
= sbr_make_f_master(ac
, sbr
, &sbr
->spectrum_params
);
1034 err
= sbr_make_f_derived(ac
, sbr
);
1036 av_log(ac
->avccontext
, AV_LOG_ERROR
,
1037 "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1043 * Decode Spectral Band Replication extension data; reference: table 4.55.
1045 * @param crc flag indicating the presence of CRC checksum
1046 * @param cnt length of TYPE_FIL syntactic element in bytes
1048 * @return Returns number of bytes consumed from the TYPE_FIL element.
1050 int ff_decode_sbr_extension(AACContext
*ac
, SpectralBandReplication
*sbr
,
1051 GetBitContext
*gb_host
, int crc
, int cnt
, int id_aac
)
1053 unsigned int num_sbr_bits
= 0, num_align_bits
;
1054 unsigned bytes_read
;
1055 GetBitContext gbc
= *gb_host
, *gb
= &gbc
;
1056 skip_bits_long(gb_host
, cnt
*8 - 4);
1060 if (!sbr
->sample_rate
)
1061 sbr
->sample_rate
= 2 * ac
->m4ac
.sample_rate
; //TODO use the nominal sample rate for arbitrary sample rate support
1062 if (!ac
->m4ac
.ext_sample_rate
)
1063 ac
->m4ac
.ext_sample_rate
= 2 * ac
->m4ac
.sample_rate
;
1066 skip_bits(gb
, 10); // bs_sbr_crc_bits; TODO - implement CRC check
1070 //Save some state from the previous frame.
1071 sbr
->kx
[0] = sbr
->kx
[1];
1072 sbr
->m
[0] = sbr
->m
[1];
1075 if (get_bits1(gb
)) // bs_header_flag
1076 num_sbr_bits
+= read_sbr_header(sbr
, gb
);
1082 num_sbr_bits
+= read_sbr_data(ac
, sbr
, gb
, id_aac
);
1084 num_align_bits
= ((cnt
<< 3) - 4 - num_sbr_bits
) & 7;
1085 bytes_read
= ((num_sbr_bits
+ num_align_bits
+ 4) >> 3);
1087 if (bytes_read
> cnt
) {
1088 av_log(ac
->avccontext
, AV_LOG_ERROR
,
1089 "Expected to read %d SBR bytes actually read %d.\n", cnt
, bytes_read
);
1094 /// Dequantization and stereo decoding (14496-3 sp04 p203)
1095 static void sbr_dequant(SpectralBandReplication
*sbr
, int id_aac
)
1100 if (id_aac
== TYPE_CPE
&& sbr
->bs_coupling
) {
1101 float alpha
= sbr
->data
[0].bs_amp_res
? 1.0f
: 0.5f
;
1102 float pan_offset
= sbr
->data
[0].bs_amp_res
? 12.0f
: 24.0f
;
1103 for (e
= 1; e
<= sbr
->data
[0].bs_num_env
; e
++) {
1104 for (k
= 0; k
< sbr
->n
[sbr
->data
[0].bs_freq_res
[e
]]; k
++) {
1105 float temp1
= exp2f(sbr
->data
[0].env_facs
[e
][k
] * alpha
+ 7.0f
);
1106 float temp2
= exp2f((pan_offset
- sbr
->data
[1].env_facs
[e
][k
]) * alpha
);
1107 float fac
= temp1
/ (1.0f
+ temp2
);
1108 sbr
->data
[0].env_facs
[e
][k
] = fac
;
1109 sbr
->data
[1].env_facs
[e
][k
] = fac
* temp2
;
1112 for (e
= 1; e
<= sbr
->data
[0].bs_num_noise
; e
++) {
1113 for (k
= 0; k
< sbr
->n_q
; k
++) {
1114 float temp1
= exp2f(NOISE_FLOOR_OFFSET
- sbr
->data
[0].noise_facs
[e
][k
] + 1);
1115 float temp2
= exp2f(12 - sbr
->data
[1].noise_facs
[e
][k
]);
1116 float fac
= temp1
/ (1.0f
+ temp2
);
1117 sbr
->data
[0].noise_facs
[e
][k
] = fac
;
1118 sbr
->data
[1].noise_facs
[e
][k
] = fac
* temp2
;
1121 } else { // SCE or one non-coupled CPE
1122 for (ch
= 0; ch
< (id_aac
== TYPE_CPE
) + 1; ch
++) {
1123 float alpha
= sbr
->data
[ch
].bs_amp_res
? 1.0f
: 0.5f
;
1124 for (e
= 1; e
<= sbr
->data
[ch
].bs_num_env
; e
++)
1125 for (k
= 0; k
< sbr
->n
[sbr
->data
[ch
].bs_freq_res
[e
]]; k
++)
1126 sbr
->data
[ch
].env_facs
[e
][k
] =
1127 exp2f(alpha
* sbr
->data
[ch
].env_facs
[e
][k
] + 6.0f
);
1128 for (e
= 1; e
<= sbr
->data
[ch
].bs_num_noise
; e
++)
1129 for (k
= 0; k
< sbr
->n_q
; k
++)
1130 sbr
->data
[ch
].noise_facs
[e
][k
] =
1131 exp2f(NOISE_FLOOR_OFFSET
- sbr
->data
[ch
].noise_facs
[e
][k
]);
1137 * Analysis QMF Bank (14496-3 sp04 p206)
1139 * @param x pointer to the beginning of the first sample window
1140 * @param W array of complex-valued samples split into subbands
1142 static void sbr_qmf_analysis(DSPContext
*dsp
, RDFTContext
*rdft
, const float *in
, float *x
,
1143 float z
[320], float W
[2][32][32][2],
1147 memcpy(W
[0], W
[1], sizeof(W
[0]));
1148 memcpy(x
, x
+1024, (320-32)*sizeof(x
[0]));
1150 dsp
->vector_fmul_scalar(x
+288, in
, scale
, 1024);
1152 memcpy(x
+288, in
, 1024*sizeof(*x
));
1153 for (i
= 0; i
< 32; i
++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
1154 // are not supported
1156 dsp
->vector_fmul_reverse(z
, sbr_qmf_window_ds
, x
, 320);
1157 for (k
= 0; k
< 64; k
++) {
1158 float f
= z
[k
] + z
[k
+ 64] + z
[k
+ 128] + z
[k
+ 192] + z
[k
+ 256];
1159 z
[k
] = f
* analysis_cos_pre
[k
];
1162 ff_rdft_calc(rdft
, z
);
1164 im
= 0.5f
* dsp
->scalarproduct_float(z
+64, analysis_sin_pre
, 64);
1165 W
[1][i
][0][0] = re
* analysis_cossin_post
[0][0] - im
* analysis_cossin_post
[0][1];
1166 W
[1][i
][0][1] = re
* analysis_cossin_post
[0][1] + im
* analysis_cossin_post
[0][0];
1167 for (k
= 1; k
< 32; k
++) {
1170 W
[1][i
][k
][0] = re
* analysis_cossin_post
[k
][0] - im
* analysis_cossin_post
[k
][1];
1171 W
[1][i
][k
][1] = re
* analysis_cossin_post
[k
][1] + im
* analysis_cossin_post
[k
][0];
1178 * Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank
1179 * (14496-3 sp04 p206)
1181 static void sbr_qmf_synthesis(DSPContext
*dsp
, FFTContext
*mdct
,
1182 float *out
, float X
[2][32][64],
1183 float mdct_buf
[2][64],
1184 float *v0
, int *v_off
, const unsigned int div
,
1185 float bias
, float scale
)
1188 const float *sbr_qmf_window
= div
? sbr_qmf_window_ds
: sbr_qmf_window_us
;
1189 int scale_and_bias
= scale
!= 1.0f
|| bias
!= 0.0f
;
1191 for (i
= 0; i
< 32; i
++) {
1193 int saved_samples
= (1280 - 128) >> div
;
1194 memcpy(&v0
[SBR_SYNTHESIS_BUF_SIZE
- saved_samples
], v0
, saved_samples
* sizeof(float));
1195 *v_off
= SBR_SYNTHESIS_BUF_SIZE
- saved_samples
- (128 >> div
);
1197 *v_off
-= 128 >> div
;
1200 for (n
= 1; n
< 64 >> div
; n
+=2) {
1201 X
[1][i
][n
] = -X
[1][i
][n
];
1204 memset(X
[0][i
]+32, 0, 32*sizeof(float));
1205 memset(X
[1][i
]+32, 0, 32*sizeof(float));
1207 ff_imdct_half(mdct
, mdct_buf
[0], X
[0][i
]);
1208 ff_imdct_half(mdct
, mdct_buf
[1], X
[1][i
]);
1210 for (n
= 0; n
< 32; n
++) {
1211 v
[ n
] = -mdct_buf
[0][63 - 2*n
] + mdct_buf
[1][2*n
];
1212 v
[ 63 - n
] = mdct_buf
[0][62 - 2*n
] + mdct_buf
[1][2*n
+ 1];
1215 for (n
= 0; n
< 64; n
++) {
1216 v
[ n
] = -mdct_buf
[0][63 - n
] + mdct_buf
[1][ n
];
1217 v
[127 - n
] = mdct_buf
[0][63 - n
] + mdct_buf
[1][ n
];
1220 dsp
->vector_fmul_add(out
, v
, sbr_qmf_window
, zero64
, 64 >> div
);
1221 dsp
->vector_fmul_add(out
, v
+ ( 192 >> div
), sbr_qmf_window
+ ( 64 >> div
), out
, 64 >> div
);
1222 dsp
->vector_fmul_add(out
, v
+ ( 256 >> div
), sbr_qmf_window
+ (128 >> div
), out
, 64 >> div
);
1223 dsp
->vector_fmul_add(out
, v
+ ( 448 >> div
), sbr_qmf_window
+ (192 >> div
), out
, 64 >> div
);
1224 dsp
->vector_fmul_add(out
, v
+ ( 512 >> div
), sbr_qmf_window
+ (256 >> div
), out
, 64 >> div
);
1225 dsp
->vector_fmul_add(out
, v
+ ( 704 >> div
), sbr_qmf_window
+ (320 >> div
), out
, 64 >> div
);
1226 dsp
->vector_fmul_add(out
, v
+ ( 768 >> div
), sbr_qmf_window
+ (384 >> div
), out
, 64 >> div
);
1227 dsp
->vector_fmul_add(out
, v
+ ( 960 >> div
), sbr_qmf_window
+ (448 >> div
), out
, 64 >> div
);
1228 dsp
->vector_fmul_add(out
, v
+ (1024 >> div
), sbr_qmf_window
+ (512 >> div
), out
, 64 >> div
);
1229 dsp
->vector_fmul_add(out
, v
+ (1216 >> div
), sbr_qmf_window
+ (576 >> div
), out
, 64 >> div
);
1231 for (n
= 0; n
< 64 >> div
; n
++)
1232 out
[n
] = out
[n
] * scale
+ bias
;
1237 static void autocorrelate(const float x
[40][2], float phi
[3][2][2], int lag
)
1240 float real_sum
= 0.0f
;
1241 float imag_sum
= 0.0f
;
1243 for (i
= 1; i
< 38; i
++) {
1244 real_sum
+= x
[i
][0] * x
[i
+lag
][0] + x
[i
][1] * x
[i
+lag
][1];
1245 imag_sum
+= x
[i
][0] * x
[i
+lag
][1] - x
[i
][1] * x
[i
+lag
][0];
1247 phi
[2-lag
][1][0] = real_sum
+ x
[ 0][0] * x
[lag
][0] + x
[ 0][1] * x
[lag
][1];
1248 phi
[2-lag
][1][1] = imag_sum
+ x
[ 0][0] * x
[lag
][1] - x
[ 0][1] * x
[lag
][0];
1250 phi
[0][0][0] = real_sum
+ x
[38][0] * x
[39][0] + x
[38][1] * x
[39][1];
1251 phi
[0][0][1] = imag_sum
+ x
[38][0] * x
[39][1] - x
[38][1] * x
[39][0];
1254 for (i
= 1; i
< 38; i
++) {
1255 real_sum
+= x
[i
][0] * x
[i
][0] + x
[i
][1] * x
[i
][1];
1257 phi
[2][1][0] = real_sum
+ x
[ 0][0] * x
[ 0][0] + x
[ 0][1] * x
[ 0][1];
1258 phi
[1][0][0] = real_sum
+ x
[38][0] * x
[38][0] + x
[38][1] * x
[38][1];
1262 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
1263 * (14496-3 sp04 p214)
1264 * Warning: This routine does not seem numerically stable.
1266 static void sbr_hf_inverse_filter(float (*alpha0
)[2], float (*alpha1
)[2],
1267 const float X_low
[32][40][2], int k0
)
1270 for (k
= 0; k
< k0
; k
++) {
1271 float phi
[3][2][2], dk
;
1273 autocorrelate(X_low
[k
], phi
, 0);
1274 autocorrelate(X_low
[k
], phi
, 1);
1275 autocorrelate(X_low
[k
], phi
, 2);
1277 dk
= phi
[2][1][0] * phi
[1][0][0] -
1278 (phi
[1][1][0] * phi
[1][1][0] + phi
[1][1][1] * phi
[1][1][1]) / 1.000001f
;
1284 float temp_real
, temp_im
;
1285 temp_real
= phi
[0][0][0] * phi
[1][1][0] -
1286 phi
[0][0][1] * phi
[1][1][1] -
1287 phi
[0][1][0] * phi
[1][0][0];
1288 temp_im
= phi
[0][0][0] * phi
[1][1][1] +
1289 phi
[0][0][1] * phi
[1][1][0] -
1290 phi
[0][1][1] * phi
[1][0][0];
1292 alpha1
[k
][0] = temp_real
/ dk
;
1293 alpha1
[k
][1] = temp_im
/ dk
;
1296 if (!phi
[1][0][0]) {
1300 float temp_real
, temp_im
;
1301 temp_real
= phi
[0][0][0] + alpha1
[k
][0] * phi
[1][1][0] +
1302 alpha1
[k
][1] * phi
[1][1][1];
1303 temp_im
= phi
[0][0][1] + alpha1
[k
][1] * phi
[1][1][0] -
1304 alpha1
[k
][0] * phi
[1][1][1];
1306 alpha0
[k
][0] = -temp_real
/ phi
[1][0][0];
1307 alpha0
[k
][1] = -temp_im
/ phi
[1][0][0];
1310 if (alpha1
[k
][0] * alpha1
[k
][0] + alpha1
[k
][1] * alpha1
[k
][1] >= 16.0f
||
1311 alpha0
[k
][0] * alpha0
[k
][0] + alpha0
[k
][1] * alpha0
[k
][1] >= 16.0f
) {
1320 /// Chirp Factors (14496-3 sp04 p214)
1321 static void sbr_chirp(SpectralBandReplication
*sbr
, SBRData
*ch_data
)
1325 static const float bw_tab
[] = { 0.0f
, 0.75f
, 0.9f
, 0.98f
};
1327 for (i
= 0; i
< sbr
->n_q
; i
++) {
1328 if (ch_data
->bs_invf_mode
[0][i
] + ch_data
->bs_invf_mode
[1][i
] == 1) {
1331 new_bw
= bw_tab
[ch_data
->bs_invf_mode
[0][i
]];
1333 if (new_bw
< ch_data
->bw_array
[i
]) {
1334 new_bw
= 0.75f
* new_bw
+ 0.25f
* ch_data
->bw_array
[i
];
1336 new_bw
= 0.90625f
* new_bw
+ 0.09375f
* ch_data
->bw_array
[i
];
1337 ch_data
->bw_array
[i
] = new_bw
< 0.015625f
? 0.0f
: new_bw
;
1341 /// Generate the subband filtered lowband
1342 static int sbr_lf_gen(AACContext
*ac
, SpectralBandReplication
*sbr
,
1343 float X_low
[32][40][2], const float W
[2][32][32][2])
1346 const int t_HFGen
= 8;
1348 memset(X_low
, 0, 32*sizeof(*X_low
));
1349 for (k
= 0; k
< sbr
->kx
[1]; k
++) {
1350 for (i
= t_HFGen
; i
< i_f
+ t_HFGen
; i
++) {
1351 X_low
[k
][i
][0] = W
[1][i
- t_HFGen
][k
][0];
1352 X_low
[k
][i
][1] = W
[1][i
- t_HFGen
][k
][1];
1355 for (k
= 0; k
< sbr
->kx
[0]; k
++) {
1356 for (i
= 0; i
< t_HFGen
; i
++) {
1357 X_low
[k
][i
][0] = W
[0][i
+ i_f
- t_HFGen
][k
][0];
1358 X_low
[k
][i
][1] = W
[0][i
+ i_f
- t_HFGen
][k
][1];
1364 /// High Frequency Generator (14496-3 sp04 p215)
1365 static int sbr_hf_gen(AACContext
*ac
, SpectralBandReplication
*sbr
,
1366 float X_high
[64][40][2], const float X_low
[32][40][2],
1367 const float (*alpha0
)[2], const float (*alpha1
)[2],
1368 const float bw_array
[5], const uint8_t *t_env
,
1374 for (j
= 0; j
< sbr
->num_patches
; j
++) {
1375 for (x
= 0; x
< sbr
->patch_num_subbands
[j
]; x
++, k
++) {
1377 const int p
= sbr
->patch_start_subband
[j
] + x
;
1378 while (g
<= sbr
->n_q
&& k
>= sbr
->f_tablenoise
[g
])
1383 av_log(ac
->avccontext
, AV_LOG_ERROR
,
1384 "ERROR : no subband found for frequency %d\n", k
);
1388 alpha
[0] = alpha1
[p
][0] * bw_array
[g
] * bw_array
[g
];
1389 alpha
[1] = alpha1
[p
][1] * bw_array
[g
] * bw_array
[g
];
1390 alpha
[2] = alpha0
[p
][0] * bw_array
[g
];
1391 alpha
[3] = alpha0
[p
][1] * bw_array
[g
];
1393 for (i
= 2 * t_env
[0]; i
< 2 * t_env
[bs_num_env
]; i
++) {
1394 const int idx
= i
+ ENVELOPE_ADJUSTMENT_OFFSET
;
1396 X_low
[p
][idx
- 2][0] * alpha
[0] -
1397 X_low
[p
][idx
- 2][1] * alpha
[1] +
1398 X_low
[p
][idx
- 1][0] * alpha
[2] -
1399 X_low
[p
][idx
- 1][1] * alpha
[3] +
1402 X_low
[p
][idx
- 2][1] * alpha
[0] +
1403 X_low
[p
][idx
- 2][0] * alpha
[1] +
1404 X_low
[p
][idx
- 1][1] * alpha
[2] +
1405 X_low
[p
][idx
- 1][0] * alpha
[3] +
1410 if (k
< sbr
->m
[1] + sbr
->kx
[1])
1411 memset(X_high
+ k
, 0, (sbr
->m
[1] + sbr
->kx
[1] - k
) * sizeof(*X_high
));
1416 /// Generate the subband filtered lowband
1417 static int sbr_x_gen(SpectralBandReplication
*sbr
, float X
[2][32][64],
1418 const float X_low
[32][40][2], const float Y
[2][38][64][2],
1423 const int i_Temp
= FFMAX(2*sbr
->data
[ch
].t_env_num_env_old
- i_f
, 0);
1424 memset(X
, 0, 2*sizeof(*X
));
1425 for (k
= 0; k
< sbr
->kx
[0]; k
++) {
1426 for (i
= 0; i
< i_Temp
; i
++) {
1427 X
[0][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][0];
1428 X
[1][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][1];
1431 for (; k
< sbr
->kx
[0] + sbr
->m
[0]; k
++) {
1432 for (i
= 0; i
< i_Temp
; i
++) {
1433 X
[0][i
][k
] = Y
[0][i
+ i_f
][k
][0];
1434 X
[1][i
][k
] = Y
[0][i
+ i_f
][k
][1];
1438 for (k
= 0; k
< sbr
->kx
[1]; k
++) {
1439 for (i
= i_Temp
; i
< i_f
; i
++) {
1440 X
[0][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][0];
1441 X
[1][i
][k
] = X_low
[k
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][1];
1444 for (; k
< sbr
->kx
[1] + sbr
->m
[1]; k
++) {
1445 for (i
= i_Temp
; i
< i_f
; i
++) {
1446 X
[0][i
][k
] = Y
[1][i
][k
][0];
1447 X
[1][i
][k
] = Y
[1][i
][k
][1];
1453 /** High Frequency Adjustment (14496-3 sp04 p217) and Mapping
1454 * (14496-3 sp04 p217)
1456 static void sbr_mapping(AACContext
*ac
, SpectralBandReplication
*sbr
,
1457 SBRData
*ch_data
, int e_a
[2])
1461 memset(ch_data
->s_indexmapped
[1], 0, 7*sizeof(ch_data
->s_indexmapped
[1]));
1462 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1463 const unsigned int ilim
= sbr
->n
[ch_data
->bs_freq_res
[e
+ 1]];
1464 uint16_t *table
= ch_data
->bs_freq_res
[e
+ 1] ? sbr
->f_tablehigh
: sbr
->f_tablelow
;
1467 for (i
= 0; i
< ilim
; i
++)
1468 for (m
= table
[i
]; m
< table
[i
+ 1]; m
++)
1469 sbr
->e_origmapped
[e
][m
- sbr
->kx
[1]] = ch_data
->env_facs
[e
+1][i
];
1471 // ch_data->bs_num_noise > 1 => 2 noise floors
1472 k
= (ch_data
->bs_num_noise
> 1) && (ch_data
->t_env
[e
] >= ch_data
->t_q
[1]);
1473 for (i
= 0; i
< sbr
->n_q
; i
++)
1474 for (m
= sbr
->f_tablenoise
[i
]; m
< sbr
->f_tablenoise
[i
+ 1]; m
++)
1475 sbr
->q_mapped
[e
][m
- sbr
->kx
[1]] = ch_data
->noise_facs
[k
+1][i
];
1477 for (i
= 0; i
< sbr
->n
[1]; i
++) {
1478 if (ch_data
->bs_add_harmonic_flag
) {
1479 const unsigned int m_midpoint
=
1480 (sbr
->f_tablehigh
[i
] + sbr
->f_tablehigh
[i
+ 1]) >> 1;
1482 ch_data
->s_indexmapped
[e
+ 1][m_midpoint
- sbr
->kx
[1]] = ch_data
->bs_add_harmonic
[i
] *
1483 (e
>= e_a
[1] || (ch_data
->s_indexmapped
[0][m_midpoint
- sbr
->kx
[1]] == 1));
1487 for (i
= 0; i
< ilim
; i
++) {
1488 int additional_sinusoid_present
= 0;
1489 for (m
= table
[i
]; m
< table
[i
+ 1]; m
++) {
1490 if (ch_data
->s_indexmapped
[e
+ 1][m
- sbr
->kx
[1]]) {
1491 additional_sinusoid_present
= 1;
1495 memset(&sbr
->s_mapped
[e
][table
[i
] - sbr
->kx
[1]], additional_sinusoid_present
,
1496 (table
[i
+ 1] - table
[i
]) * sizeof(sbr
->s_mapped
[e
][0]));
1500 memcpy(ch_data
->s_indexmapped
[0], ch_data
->s_indexmapped
[ch_data
->bs_num_env
], sizeof(ch_data
->s_indexmapped
[0]));
1503 /// Estimation of current envelope (14496-3 sp04 p218)
1504 static void sbr_env_estimate(float (*e_curr
)[48], float X_high
[64][40][2],
1505 SpectralBandReplication
*sbr
, SBRData
*ch_data
)
1509 if (sbr
->bs_interpol_freq
) {
1510 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1511 const float recip_env_size
= 0.5f
/ (ch_data
->t_env
[e
+ 1] - ch_data
->t_env
[e
]);
1512 int ilb
= ch_data
->t_env
[e
] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1513 int iub
= ch_data
->t_env
[e
+ 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1515 for (m
= 0; m
< sbr
->m
[1]; m
++) {
1518 for (i
= ilb
; i
< iub
; i
++) {
1519 sum
+= X_high
[m
+ sbr
->kx
[1]][i
][0] * X_high
[m
+ sbr
->kx
[1]][i
][0] +
1520 X_high
[m
+ sbr
->kx
[1]][i
][1] * X_high
[m
+ sbr
->kx
[1]][i
][1];
1522 e_curr
[e
][m
] = sum
* recip_env_size
;
1528 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1529 const int env_size
= 2 * (ch_data
->t_env
[e
+ 1] - ch_data
->t_env
[e
]);
1530 int ilb
= ch_data
->t_env
[e
] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1531 int iub
= ch_data
->t_env
[e
+ 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET
;
1532 const uint16_t *table
= ch_data
->bs_freq_res
[e
+ 1] ? sbr
->f_tablehigh
: sbr
->f_tablelow
;
1534 for (p
= 0; p
< sbr
->n
[ch_data
->bs_freq_res
[e
+ 1]]; p
++) {
1536 const int den
= env_size
* (table
[p
+ 1] - table
[p
]);
1538 for (k
= table
[p
]; k
< table
[p
+ 1]; k
++) {
1539 for (i
= ilb
; i
< iub
; i
++) {
1540 sum
+= X_high
[k
][i
][0] * X_high
[k
][i
][0] +
1541 X_high
[k
][i
][1] * X_high
[k
][i
][1];
1545 for (k
= table
[p
]; k
< table
[p
+ 1]; k
++) {
1546 e_curr
[e
][k
- sbr
->kx
[1]] = sum
;
1554 * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
1555 * and Calculation of gain (14496-3 sp04 p219)
1557 static void sbr_gain_calc(AACContext
*ac
, SpectralBandReplication
*sbr
,
1558 SBRData
*ch_data
, const int e_a
[2])
1561 // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
1562 static const float limgain
[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
1564 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1565 int delta
= !((e
== e_a
[1]) || (e
== e_a
[0]));
1566 for (k
= 0; k
< sbr
->n_lim
; k
++) {
1567 float gain_boost
, gain_max
;
1568 float sum
[2] = { 0.0f
, 0.0f
};
1569 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1570 const float temp
= sbr
->e_origmapped
[e
][m
] / (1.0f
+ sbr
->q_mapped
[e
][m
]);
1571 sbr
->q_m
[e
][m
] = sqrtf(temp
* sbr
->q_mapped
[e
][m
]);
1572 sbr
->s_m
[e
][m
] = sqrtf(temp
* ch_data
->s_indexmapped
[e
+ 1][m
]);
1573 if (!sbr
->s_mapped
[e
][m
]) {
1574 sbr
->gain
[e
][m
] = sqrtf(sbr
->e_origmapped
[e
][m
] /
1575 ((1.0f
+ sbr
->e_curr
[e
][m
]) *
1576 (1.0f
+ sbr
->q_mapped
[e
][m
] * delta
)));
1578 sbr
->gain
[e
][m
] = sqrtf(sbr
->e_origmapped
[e
][m
] * sbr
->q_mapped
[e
][m
] /
1579 ((1.0f
+ sbr
->e_curr
[e
][m
]) *
1580 (1.0f
+ sbr
->q_mapped
[e
][m
])));
1583 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1584 sum
[0] += sbr
->e_origmapped
[e
][m
];
1585 sum
[1] += sbr
->e_curr
[e
][m
];
1587 gain_max
= limgain
[sbr
->bs_limiter_gains
] * sqrtf((FLT_EPSILON
+ sum
[0]) / (FLT_EPSILON
+ sum
[1]));
1588 gain_max
= FFMIN(100000, gain_max
);
1589 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1590 float q_m_max
= sbr
->q_m
[e
][m
] * gain_max
/ sbr
->gain
[e
][m
];
1591 sbr
->q_m
[e
][m
] = FFMIN(sbr
->q_m
[e
][m
], q_m_max
);
1592 sbr
->gain
[e
][m
] = FFMIN(sbr
->gain
[e
][m
], gain_max
);
1594 sum
[0] = sum
[1] = 0.0f
;
1595 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1596 sum
[0] += sbr
->e_origmapped
[e
][m
];
1597 sum
[1] += sbr
->e_curr
[e
][m
] * sbr
->gain
[e
][m
] * sbr
->gain
[e
][m
]
1598 + sbr
->s_m
[e
][m
] * sbr
->s_m
[e
][m
]
1599 + (delta
&& !sbr
->s_m
[e
][m
]) * sbr
->q_m
[e
][m
] * sbr
->q_m
[e
][m
];
1601 gain_boost
= sqrtf((FLT_EPSILON
+ sum
[0]) / (FLT_EPSILON
+ sum
[1]));
1602 gain_boost
= FFMIN(1.584893192, gain_boost
);
1603 for (m
= sbr
->f_tablelim
[k
] - sbr
->kx
[1]; m
< sbr
->f_tablelim
[k
+ 1] - sbr
->kx
[1]; m
++) {
1604 sbr
->gain
[e
][m
] *= gain_boost
;
1605 sbr
->q_m
[e
][m
] *= gain_boost
;
1606 sbr
->s_m
[e
][m
] *= gain_boost
;
1612 /// Assembling HF Signals (14496-3 sp04 p220)
1613 static void sbr_hf_assemble(float Y
[2][38][64][2], const float X_high
[64][40][2],
1614 SpectralBandReplication
*sbr
, SBRData
*ch_data
,
1618 const int h_SL
= 4 * !sbr
->bs_smoothing_mode
;
1619 const int kx
= sbr
->kx
[1];
1620 const int m_max
= sbr
->m
[1];
1621 static const float h_smooth
[5] = {
1628 static const int8_t phi
[2][4] = {
1629 { 1, 0, -1, 0}, // real
1630 { 0, 1, 0, -1}, // imaginary
1632 float (*g_temp
)[48] = ch_data
->g_temp
, (*q_temp
)[48] = ch_data
->q_temp
;
1633 int indexnoise
= ch_data
->f_indexnoise
;
1634 int indexsine
= ch_data
->f_indexsine
;
1635 memcpy(Y
[0], Y
[1], sizeof(Y
[0]));
1638 for (i
= 0; i
< h_SL
; i
++) {
1639 memcpy(g_temp
[i
+ 2*ch_data
->t_env
[0]], sbr
->gain
[0], m_max
* sizeof(sbr
->gain
[0][0]));
1640 memcpy(q_temp
[i
+ 2*ch_data
->t_env
[0]], sbr
->q_m
[0], m_max
* sizeof(sbr
->q_m
[0][0]));
1643 memcpy(g_temp
[2*ch_data
->t_env
[0]], g_temp
[2*ch_data
->t_env_num_env_old
], 4*sizeof(g_temp
[0]));
1644 memcpy(q_temp
[2*ch_data
->t_env
[0]], q_temp
[2*ch_data
->t_env_num_env_old
], 4*sizeof(q_temp
[0]));
1647 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1648 for (i
= 2 * ch_data
->t_env
[e
]; i
< 2 * ch_data
->t_env
[e
+ 1]; i
++) {
1649 memcpy(g_temp
[h_SL
+ i
], sbr
->gain
[e
], m_max
* sizeof(sbr
->gain
[0][0]));
1650 memcpy(q_temp
[h_SL
+ i
], sbr
->q_m
[e
], m_max
* sizeof(sbr
->q_m
[0][0]));
1654 for (e
= 0; e
< ch_data
->bs_num_env
; e
++) {
1655 for (i
= 2 * ch_data
->t_env
[e
]; i
< 2 * ch_data
->t_env
[e
+ 1]; i
++) {
1656 int phi_sign
= (1 - 2*(kx
& 1));
1658 if (h_SL
&& e
!= e_a
[0] && e
!= e_a
[1]) {
1659 for (m
= 0; m
< m_max
; m
++) {
1660 const int idx1
= i
+ h_SL
;
1661 float g_filt
= 0.0f
;
1662 for (j
= 0; j
<= h_SL
; j
++)
1663 g_filt
+= g_temp
[idx1
- j
][m
] * h_smooth
[j
];
1664 Y
[1][i
][m
+ kx
][0] =
1665 X_high
[m
+ kx
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][0] * g_filt
;
1666 Y
[1][i
][m
+ kx
][1] =
1667 X_high
[m
+ kx
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][1] * g_filt
;
1670 for (m
= 0; m
< m_max
; m
++) {
1671 const float g_filt
= g_temp
[i
+ h_SL
][m
];
1672 Y
[1][i
][m
+ kx
][0] =
1673 X_high
[m
+ kx
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][0] * g_filt
;
1674 Y
[1][i
][m
+ kx
][1] =
1675 X_high
[m
+ kx
][i
+ ENVELOPE_ADJUSTMENT_OFFSET
][1] * g_filt
;
1679 if (e
!= e_a
[0] && e
!= e_a
[1]) {
1680 for (m
= 0; m
< m_max
; m
++) {
1681 indexnoise
= (indexnoise
+ 1) & 0x1ff;
1682 if (sbr
->s_m
[e
][m
]) {
1683 Y
[1][i
][m
+ kx
][0] +=
1684 sbr
->s_m
[e
][m
] * phi
[0][indexsine
];
1685 Y
[1][i
][m
+ kx
][1] +=
1686 sbr
->s_m
[e
][m
] * (phi
[1][indexsine
] * phi_sign
);
1690 const int idx1
= i
+ h_SL
;
1692 for (j
= 0; j
<= h_SL
; j
++)
1693 q_filt
+= q_temp
[idx1
- j
][m
] * h_smooth
[j
];
1695 q_filt
= q_temp
[i
][m
];
1697 Y
[1][i
][m
+ kx
][0] +=
1698 q_filt
* sbr_noise_table
[indexnoise
][0];
1699 Y
[1][i
][m
+ kx
][1] +=
1700 q_filt
* sbr_noise_table
[indexnoise
][1];
1702 phi_sign
= -phi_sign
;
1705 indexnoise
= (indexnoise
+ m_max
) & 0x1ff;
1706 for (m
= 0; m
< m_max
; m
++) {
1707 Y
[1][i
][m
+ kx
][0] +=
1708 sbr
->s_m
[e
][m
] * phi
[0][indexsine
];
1709 Y
[1][i
][m
+ kx
][1] +=
1710 sbr
->s_m
[e
][m
] * (phi
[1][indexsine
] * phi_sign
);
1711 phi_sign
= -phi_sign
;
1714 indexsine
= (indexsine
+ 1) & 3;
1717 ch_data
->f_indexnoise
= indexnoise
;
1718 ch_data
->f_indexsine
= indexsine
;
1721 void ff_sbr_apply(AACContext
*ac
, SpectralBandReplication
*sbr
, int id_aac
,
1724 int downsampled
= ac
->m4ac
.ext_sample_rate
< sbr
->sample_rate
;
1726 int nch
= (id_aac
== TYPE_CPE
) ? 2 : 1;
1729 sbr_dequant(sbr
, id_aac
);
1731 for (ch
= 0; ch
< nch
; ch
++) {
1732 /* decode channel */
1733 sbr_qmf_analysis(&ac
->dsp
, &sbr
->rdft
, ch
? R
: L
, sbr
->data
[ch
].analysis_filterbank_samples
,
1734 (float*)sbr
->qmf_filter_scratch
,
1735 sbr
->data
[ch
].W
, 1/(-1024 * ac
->sf_scale
));
1736 sbr_lf_gen(ac
, sbr
, sbr
->X_low
, sbr
->data
[ch
].W
);
1738 sbr_hf_inverse_filter(sbr
->alpha0
, sbr
->alpha1
, sbr
->X_low
, sbr
->k
[0]);
1739 sbr_chirp(sbr
, &sbr
->data
[ch
]);
1740 sbr_hf_gen(ac
, sbr
, sbr
->X_high
, sbr
->X_low
, sbr
->alpha0
, sbr
->alpha1
,
1741 sbr
->data
[ch
].bw_array
, sbr
->data
[ch
].t_env
,
1742 sbr
->data
[ch
].bs_num_env
);
1745 sbr_mapping(ac
, sbr
, &sbr
->data
[ch
], sbr
->data
[ch
].e_a
);
1746 sbr_env_estimate(sbr
->e_curr
, sbr
->X_high
, sbr
, &sbr
->data
[ch
]);
1747 sbr_gain_calc(ac
, sbr
, &sbr
->data
[ch
], sbr
->data
[ch
].e_a
);
1748 sbr_hf_assemble(sbr
->data
[ch
].Y
, sbr
->X_high
, sbr
, &sbr
->data
[ch
],
1753 sbr_x_gen(sbr
, sbr
->X
[ch
], sbr
->X_low
, sbr
->data
[ch
].Y
, ch
);
1755 sbr_qmf_synthesis(&ac
->dsp
, &sbr
->mdct
, L
, sbr
->X
[0], sbr
->qmf_filter_scratch
,
1756 sbr
->data
[0].synthesis_filterbank_samples
,
1757 &sbr
->data
[0].synthesis_filterbank_samples_offset
,
1759 ac
->add_bias
, -1024 * ac
->sf_scale
);
1761 sbr_qmf_synthesis(&ac
->dsp
, &sbr
->mdct
, R
, sbr
->X
[1], sbr
->qmf_filter_scratch
,
1762 sbr
->data
[1].synthesis_filterbank_samples
,
1763 &sbr
->data
[1].synthesis_filterbank_samples_offset
,
1765 ac
->add_bias
, -1024 * ac
->sf_scale
);