blob: 750131c64c4ad856a5c869de898d6ae17da5700b
1 | /* |
2 | * AAC Spectral Band Replication decoding functions |
3 | * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl ) |
4 | * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com> |
5 | * |
6 | * Fixed point code |
7 | * Copyright (c) 2013 |
8 | * MIPS Technologies, Inc., California. |
9 | * |
10 | * This file is part of FFmpeg. |
11 | * |
12 | * FFmpeg is free software; you can redistribute it and/or |
13 | * modify it under the terms of the GNU Lesser General Public |
14 | * License as published by the Free Software Foundation; either |
15 | * version 2.1 of the License, or (at your option) any later version. |
16 | * |
17 | * FFmpeg is distributed in the hope that it will be useful, |
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
20 | * Lesser General Public License for more details. |
21 | * |
22 | * You should have received a copy of the GNU Lesser General Public |
23 | * License along with FFmpeg; if not, write to the Free Software |
24 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
25 | */ |
26 | |
27 | /** |
28 | * @file |
29 | * AAC Spectral Band Replication decoding functions |
30 | * @author Robert Swain ( rob opendot cl ) |
31 | * @author Stanislav Ocovaj ( stanislav.ocovaj@imgtec.com ) |
32 | * @author Zoran Basaric ( zoran.basaric@imgtec.com ) |
33 | */ |
34 | |
35 | #include "libavutil/qsort.h" |
36 | |
37 | av_cold void AAC_RENAME(ff_aac_sbr_init)(void) |
38 | { |
39 | static const struct { |
40 | const void *sbr_codes, *sbr_bits; |
41 | const unsigned int table_size, elem_size; |
42 | } sbr_tmp[] = { |
43 | SBR_VLC_ROW(t_huffman_env_1_5dB), |
44 | SBR_VLC_ROW(f_huffman_env_1_5dB), |
45 | SBR_VLC_ROW(t_huffman_env_bal_1_5dB), |
46 | SBR_VLC_ROW(f_huffman_env_bal_1_5dB), |
47 | SBR_VLC_ROW(t_huffman_env_3_0dB), |
48 | SBR_VLC_ROW(f_huffman_env_3_0dB), |
49 | SBR_VLC_ROW(t_huffman_env_bal_3_0dB), |
50 | SBR_VLC_ROW(f_huffman_env_bal_3_0dB), |
51 | SBR_VLC_ROW(t_huffman_noise_3_0dB), |
52 | SBR_VLC_ROW(t_huffman_noise_bal_3_0dB), |
53 | }; |
54 | |
55 | // SBR VLC table initialization |
56 | SBR_INIT_VLC_STATIC(0, 1098); |
57 | SBR_INIT_VLC_STATIC(1, 1092); |
58 | SBR_INIT_VLC_STATIC(2, 768); |
59 | SBR_INIT_VLC_STATIC(3, 1026); |
60 | SBR_INIT_VLC_STATIC(4, 1058); |
61 | SBR_INIT_VLC_STATIC(5, 1052); |
62 | SBR_INIT_VLC_STATIC(6, 544); |
63 | SBR_INIT_VLC_STATIC(7, 544); |
64 | SBR_INIT_VLC_STATIC(8, 592); |
65 | SBR_INIT_VLC_STATIC(9, 512); |
66 | |
67 | aacsbr_tableinit(); |
68 | |
69 | AAC_RENAME(ff_ps_init)(); |
70 | } |
71 | |
72 | /** Places SBR in pure upsampling mode. */ |
73 | static void sbr_turnoff(SpectralBandReplication *sbr) { |
74 | sbr->start = 0; |
75 | sbr->ready_for_dequant = 0; |
76 | // Init defults used in pure upsampling mode |
77 | sbr->kx[1] = 32; //Typo in spec, kx' inits to 32 |
78 | sbr->m[1] = 0; |
79 | // Reset values for first SBR header |
80 | sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1; |
81 | memset(&sbr->spectrum_params, -1, sizeof(SpectrumParameters)); |
82 | } |
83 | |
84 | av_cold void AAC_RENAME(ff_aac_sbr_ctx_init)(AACContext *ac, SpectralBandReplication *sbr, int id_aac) |
85 | { |
86 | if(sbr->mdct.mdct_bits) |
87 | return; |
88 | sbr->kx[0] = sbr->kx[1]; |
89 | sbr->id_aac = id_aac; |
90 | sbr_turnoff(sbr); |
91 | sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128); |
92 | sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128); |
93 | /* SBR requires samples to be scaled to +/-32768.0 to work correctly. |
94 | * mdct scale factors are adjusted to scale up from +/-1.0 at analysis |
95 | * and scale back down at synthesis. */ |
96 | AAC_RENAME_32(ff_mdct_init)(&sbr->mdct, 7, 1, 1.0 / (64 * 32768.0)); |
97 | AAC_RENAME_32(ff_mdct_init)(&sbr->mdct_ana, 7, 1, -2.0 * 32768.0); |
98 | AAC_RENAME(ff_ps_ctx_init)(&sbr->ps); |
99 | AAC_RENAME(ff_sbrdsp_init)(&sbr->dsp); |
100 | aacsbr_func_ptr_init(&sbr->c); |
101 | } |
102 | |
103 | av_cold void AAC_RENAME(ff_aac_sbr_ctx_close)(SpectralBandReplication *sbr) |
104 | { |
105 | AAC_RENAME_32(ff_mdct_end)(&sbr->mdct); |
106 | AAC_RENAME_32(ff_mdct_end)(&sbr->mdct_ana); |
107 | } |
108 | |
109 | static int qsort_comparison_function_int16(const void *a, const void *b) |
110 | { |
111 | return *(const int16_t *)a - *(const int16_t *)b; |
112 | } |
113 | |
114 | static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle) |
115 | { |
116 | int i; |
117 | for (i = 0; i <= last_el; i++) |
118 | if (table[i] == needle) |
119 | return 1; |
120 | return 0; |
121 | } |
122 | |
123 | /// Limiter Frequency Band Table (14496-3 sp04 p198) |
124 | static void sbr_make_f_tablelim(SpectralBandReplication *sbr) |
125 | { |
126 | int k; |
127 | if (sbr->bs_limiter_bands > 0) { |
128 | static const INTFLOAT bands_warped[3] = { Q23(1.32715174233856803909f), //2^(0.49/1.2) |
129 | Q23(1.18509277094158210129f), //2^(0.49/2) |
130 | Q23(1.11987160404675912501f) }; //2^(0.49/3) |
131 | const INTFLOAT lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1]; |
132 | int16_t patch_borders[7]; |
133 | uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim; |
134 | |
135 | patch_borders[0] = sbr->kx[1]; |
136 | for (k = 1; k <= sbr->num_patches; k++) |
137 | patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1]; |
138 | |
139 | memcpy(sbr->f_tablelim, sbr->f_tablelow, |
140 | (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0])); |
141 | if (sbr->num_patches > 1) |
142 | memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1, |
143 | (sbr->num_patches - 1) * sizeof(patch_borders[0])); |
144 | |
145 | AV_QSORT(sbr->f_tablelim, sbr->num_patches + sbr->n[0], |
146 | uint16_t, |
147 | qsort_comparison_function_int16); |
148 | |
149 | sbr->n_lim = sbr->n[0] + sbr->num_patches - 1; |
150 | while (out < sbr->f_tablelim + sbr->n_lim) { |
151 | #if USE_FIXED |
152 | if ((*in << 23) >= *out * lim_bands_per_octave_warped) { |
153 | #else |
154 | if (*in >= *out * lim_bands_per_octave_warped) { |
155 | #endif /* USE_FIXED */ |
156 | *++out = *in++; |
157 | } else if (*in == *out || |
158 | !in_table_int16(patch_borders, sbr->num_patches, *in)) { |
159 | in++; |
160 | sbr->n_lim--; |
161 | } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) { |
162 | *out = *in++; |
163 | sbr->n_lim--; |
164 | } else { |
165 | *++out = *in++; |
166 | } |
167 | } |
168 | } else { |
169 | sbr->f_tablelim[0] = sbr->f_tablelow[0]; |
170 | sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]]; |
171 | sbr->n_lim = 1; |
172 | } |
173 | } |
174 | |
175 | static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb) |
176 | { |
177 | unsigned int cnt = get_bits_count(gb); |
178 | uint8_t bs_header_extra_1; |
179 | uint8_t bs_header_extra_2; |
180 | int old_bs_limiter_bands = sbr->bs_limiter_bands; |
181 | SpectrumParameters old_spectrum_params; |
182 | |
183 | sbr->start = 1; |
184 | sbr->ready_for_dequant = 0; |
185 | |
186 | // Save last spectrum parameters variables to compare to new ones |
187 | memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)); |
188 | |
189 | sbr->bs_amp_res_header = get_bits1(gb); |
190 | sbr->spectrum_params.bs_start_freq = get_bits(gb, 4); |
191 | sbr->spectrum_params.bs_stop_freq = get_bits(gb, 4); |
192 | sbr->spectrum_params.bs_xover_band = get_bits(gb, 3); |
193 | skip_bits(gb, 2); // bs_reserved |
194 | |
195 | bs_header_extra_1 = get_bits1(gb); |
196 | bs_header_extra_2 = get_bits1(gb); |
197 | |
198 | if (bs_header_extra_1) { |
199 | sbr->spectrum_params.bs_freq_scale = get_bits(gb, 2); |
200 | sbr->spectrum_params.bs_alter_scale = get_bits1(gb); |
201 | sbr->spectrum_params.bs_noise_bands = get_bits(gb, 2); |
202 | } else { |
203 | sbr->spectrum_params.bs_freq_scale = 2; |
204 | sbr->spectrum_params.bs_alter_scale = 1; |
205 | sbr->spectrum_params.bs_noise_bands = 2; |
206 | } |
207 | |
208 | // Check if spectrum parameters changed |
209 | if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters))) |
210 | sbr->reset = 1; |
211 | |
212 | if (bs_header_extra_2) { |
213 | sbr->bs_limiter_bands = get_bits(gb, 2); |
214 | sbr->bs_limiter_gains = get_bits(gb, 2); |
215 | sbr->bs_interpol_freq = get_bits1(gb); |
216 | sbr->bs_smoothing_mode = get_bits1(gb); |
217 | } else { |
218 | sbr->bs_limiter_bands = 2; |
219 | sbr->bs_limiter_gains = 2; |
220 | sbr->bs_interpol_freq = 1; |
221 | sbr->bs_smoothing_mode = 1; |
222 | } |
223 | |
224 | if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset) |
225 | sbr_make_f_tablelim(sbr); |
226 | |
227 | return get_bits_count(gb) - cnt; |
228 | } |
229 | |
230 | static int array_min_int16(const int16_t *array, int nel) |
231 | { |
232 | int i, min = array[0]; |
233 | for (i = 1; i < nel; i++) |
234 | min = FFMIN(array[i], min); |
235 | return min; |
236 | } |
237 | |
238 | static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band) |
239 | { |
240 | // Requirements (14496-3 sp04 p205) |
241 | if (n_master <= 0) { |
242 | av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master); |
243 | return -1; |
244 | } |
245 | if (bs_xover_band >= n_master) { |
246 | av_log(avctx, AV_LOG_ERROR, |
247 | "Invalid bitstream, crossover band index beyond array bounds: %d\n", |
248 | bs_xover_band); |
249 | return -1; |
250 | } |
251 | return 0; |
252 | } |
253 | |
254 | /// Master Frequency Band Table (14496-3 sp04 p194) |
255 | static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr, |
256 | SpectrumParameters *spectrum) |
257 | { |
258 | unsigned int temp, max_qmf_subbands = 0; |
259 | unsigned int start_min, stop_min; |
260 | int k; |
261 | const int8_t *sbr_offset_ptr; |
262 | int16_t stop_dk[13]; |
263 | |
264 | if (sbr->sample_rate < 32000) { |
265 | temp = 3000; |
266 | } else if (sbr->sample_rate < 64000) { |
267 | temp = 4000; |
268 | } else |
269 | temp = 5000; |
270 | |
271 | switch (sbr->sample_rate) { |
272 | case 16000: |
273 | sbr_offset_ptr = sbr_offset[0]; |
274 | break; |
275 | case 22050: |
276 | sbr_offset_ptr = sbr_offset[1]; |
277 | break; |
278 | case 24000: |
279 | sbr_offset_ptr = sbr_offset[2]; |
280 | break; |
281 | case 32000: |
282 | sbr_offset_ptr = sbr_offset[3]; |
283 | break; |
284 | case 44100: case 48000: case 64000: |
285 | sbr_offset_ptr = sbr_offset[4]; |
286 | break; |
287 | case 88200: case 96000: case 128000: case 176400: case 192000: |
288 | sbr_offset_ptr = sbr_offset[5]; |
289 | break; |
290 | default: |
291 | av_log(ac->avctx, AV_LOG_ERROR, |
292 | "Unsupported sample rate for SBR: %d\n", sbr->sample_rate); |
293 | return -1; |
294 | } |
295 | |
296 | start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate; |
297 | stop_min = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate; |
298 | |
299 | sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq]; |
300 | |
301 | if (spectrum->bs_stop_freq < 14) { |
302 | sbr->k[2] = stop_min; |
303 | make_bands(stop_dk, stop_min, 64, 13); |
304 | AV_QSORT(stop_dk, 13, int16_t, qsort_comparison_function_int16); |
305 | for (k = 0; k < spectrum->bs_stop_freq; k++) |
306 | sbr->k[2] += stop_dk[k]; |
307 | } else if (spectrum->bs_stop_freq == 14) { |
308 | sbr->k[2] = 2*sbr->k[0]; |
309 | } else if (spectrum->bs_stop_freq == 15) { |
310 | sbr->k[2] = 3*sbr->k[0]; |
311 | } else { |
312 | av_log(ac->avctx, AV_LOG_ERROR, |
313 | "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq); |
314 | return -1; |
315 | } |
316 | sbr->k[2] = FFMIN(64, sbr->k[2]); |
317 | |
318 | // Requirements (14496-3 sp04 p205) |
319 | if (sbr->sample_rate <= 32000) { |
320 | max_qmf_subbands = 48; |
321 | } else if (sbr->sample_rate == 44100) { |
322 | max_qmf_subbands = 35; |
323 | } else if (sbr->sample_rate >= 48000) |
324 | max_qmf_subbands = 32; |
325 | else |
326 | av_assert0(0); |
327 | |
328 | if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) { |
329 | av_log(ac->avctx, AV_LOG_ERROR, |
330 | "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]); |
331 | return -1; |
332 | } |
333 | |
334 | if (!spectrum->bs_freq_scale) { |
335 | int dk, k2diff; |
336 | |
337 | dk = spectrum->bs_alter_scale + 1; |
338 | sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1; |
339 | if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band)) |
340 | return -1; |
341 | |
342 | for (k = 1; k <= sbr->n_master; k++) |
343 | sbr->f_master[k] = dk; |
344 | |
345 | k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk; |
346 | if (k2diff < 0) { |
347 | sbr->f_master[1]--; |
348 | sbr->f_master[2]-= (k2diff < -1); |
349 | } else if (k2diff) { |
350 | sbr->f_master[sbr->n_master]++; |
351 | } |
352 | |
353 | sbr->f_master[0] = sbr->k[0]; |
354 | for (k = 1; k <= sbr->n_master; k++) |
355 | sbr->f_master[k] += sbr->f_master[k - 1]; |
356 | |
357 | } else { |
358 | int half_bands = 7 - spectrum->bs_freq_scale; // bs_freq_scale = {1,2,3} |
359 | int two_regions, num_bands_0; |
360 | int vdk0_max, vdk1_min; |
361 | int16_t vk0[49]; |
362 | #if USE_FIXED |
363 | int tmp, nz = 0; |
364 | #endif /* USE_FIXED */ |
365 | |
366 | if (49 * sbr->k[2] > 110 * sbr->k[0]) { |
367 | two_regions = 1; |
368 | sbr->k[1] = 2 * sbr->k[0]; |
369 | } else { |
370 | two_regions = 0; |
371 | sbr->k[1] = sbr->k[2]; |
372 | } |
373 | |
374 | #if USE_FIXED |
375 | tmp = (sbr->k[1] << 23) / sbr->k[0]; |
376 | while (tmp < 0x40000000) { |
377 | tmp <<= 1; |
378 | nz++; |
379 | } |
380 | tmp = fixed_log(tmp - 0x80000000); |
381 | tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30); |
382 | tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands; |
383 | num_bands_0 = ((tmp + 0x400000) >> 23) * 2; |
384 | #else |
385 | num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2; |
386 | #endif /* USE_FIXED */ |
387 | |
388 | if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205) |
389 | av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0); |
390 | return -1; |
391 | } |
392 | |
393 | vk0[0] = 0; |
394 | |
395 | make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0); |
396 | |
397 | AV_QSORT(vk0 + 1, num_bands_0, int16_t, qsort_comparison_function_int16); |
398 | vdk0_max = vk0[num_bands_0]; |
399 | |
400 | vk0[0] = sbr->k[0]; |
401 | for (k = 1; k <= num_bands_0; k++) { |
402 | if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205) |
403 | av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]); |
404 | return -1; |
405 | } |
406 | vk0[k] += vk0[k-1]; |
407 | } |
408 | |
409 | if (two_regions) { |
410 | int16_t vk1[49]; |
411 | #if USE_FIXED |
412 | int num_bands_1; |
413 | |
414 | tmp = (sbr->k[2] << 23) / sbr->k[1]; |
415 | nz = 0; |
416 | while (tmp < 0x40000000) { |
417 | tmp <<= 1; |
418 | nz++; |
419 | } |
420 | tmp = fixed_log(tmp - 0x80000000); |
421 | tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30); |
422 | tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands; |
423 | if (spectrum->bs_alter_scale) |
424 | tmp = (int)(((int64_t)tmp * CONST_076923 + 0x40000000) >> 31); |
425 | num_bands_1 = ((tmp + 0x400000) >> 23) * 2; |
426 | #else |
427 | float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f |
428 | : 1.0f; // bs_alter_scale = {0,1} |
429 | int num_bands_1 = lrintf(half_bands * invwarp * |
430 | log2f(sbr->k[2] / (float)sbr->k[1])) * 2; |
431 | #endif /* USE_FIXED */ |
432 | make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1); |
433 | |
434 | vdk1_min = array_min_int16(vk1 + 1, num_bands_1); |
435 | |
436 | if (vdk1_min < vdk0_max) { |
437 | int change; |
438 | AV_QSORT(vk1 + 1, num_bands_1, int16_t, qsort_comparison_function_int16); |
439 | change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1); |
440 | vk1[1] += change; |
441 | vk1[num_bands_1] -= change; |
442 | } |
443 | |
444 | AV_QSORT(vk1 + 1, num_bands_1, int16_t, qsort_comparison_function_int16); |
445 | |
446 | vk1[0] = sbr->k[1]; |
447 | for (k = 1; k <= num_bands_1; k++) { |
448 | if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205) |
449 | av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]); |
450 | return -1; |
451 | } |
452 | vk1[k] += vk1[k-1]; |
453 | } |
454 | |
455 | sbr->n_master = num_bands_0 + num_bands_1; |
456 | if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band)) |
457 | return -1; |
458 | memcpy(&sbr->f_master[0], vk0, |
459 | (num_bands_0 + 1) * sizeof(sbr->f_master[0])); |
460 | memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1, |
461 | num_bands_1 * sizeof(sbr->f_master[0])); |
462 | |
463 | } else { |
464 | sbr->n_master = num_bands_0; |
465 | if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band)) |
466 | return -1; |
467 | memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0])); |
468 | } |
469 | } |
470 | |
471 | return 0; |
472 | } |
473 | |
474 | /// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46) |
475 | static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr) |
476 | { |
477 | int i, k, last_k = -1, last_msb = -1, sb = 0; |
478 | int msb = sbr->k[0]; |
479 | int usb = sbr->kx[1]; |
480 | int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate; |
481 | |
482 | sbr->num_patches = 0; |
483 | |
484 | if (goal_sb < sbr->kx[1] + sbr->m[1]) { |
485 | for (k = 0; sbr->f_master[k] < goal_sb; k++) ; |
486 | } else |
487 | k = sbr->n_master; |
488 | |
489 | do { |
490 | int odd = 0; |
491 | if (k == last_k && msb == last_msb) { |
492 | av_log(ac->avctx, AV_LOG_ERROR, "patch construction failed\n"); |
493 | return AVERROR_INVALIDDATA; |
494 | } |
495 | last_k = k; |
496 | last_msb = msb; |
497 | for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) { |
498 | sb = sbr->f_master[i]; |
499 | odd = (sb + sbr->k[0]) & 1; |
500 | } |
501 | |
502 | // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5. |
503 | // After this check the final number of patches can still be six which is |
504 | // illegal however the Coding Technologies decoder check stream has a final |
505 | // count of 6 patches |
506 | if (sbr->num_patches > 5) { |
507 | av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches); |
508 | return -1; |
509 | } |
510 | |
511 | sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0); |
512 | sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches]; |
513 | |
514 | if (sbr->patch_num_subbands[sbr->num_patches] > 0) { |
515 | usb = sb; |
516 | msb = sb; |
517 | sbr->num_patches++; |
518 | } else |
519 | msb = sbr->kx[1]; |
520 | |
521 | if (sbr->f_master[k] - sb < 3) |
522 | k = sbr->n_master; |
523 | } while (sb != sbr->kx[1] + sbr->m[1]); |
524 | |
525 | if (sbr->num_patches > 1 && |
526 | sbr->patch_num_subbands[sbr->num_patches - 1] < 3) |
527 | sbr->num_patches--; |
528 | |
529 | return 0; |
530 | } |
531 | |
532 | /// Derived Frequency Band Tables (14496-3 sp04 p197) |
533 | static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr) |
534 | { |
535 | int k, temp; |
536 | #if USE_FIXED |
537 | int nz = 0; |
538 | #endif /* USE_FIXED */ |
539 | |
540 | sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band; |
541 | sbr->n[0] = (sbr->n[1] + 1) >> 1; |
542 | |
543 | memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band], |
544 | (sbr->n[1] + 1) * sizeof(sbr->f_master[0])); |
545 | sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0]; |
546 | sbr->kx[1] = sbr->f_tablehigh[0]; |
547 | |
548 | // Requirements (14496-3 sp04 p205) |
549 | if (sbr->kx[1] + sbr->m[1] > 64) { |
550 | av_log(ac->avctx, AV_LOG_ERROR, |
551 | "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]); |
552 | return -1; |
553 | } |
554 | if (sbr->kx[1] > 32) { |
555 | av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]); |
556 | return -1; |
557 | } |
558 | |
559 | sbr->f_tablelow[0] = sbr->f_tablehigh[0]; |
560 | temp = sbr->n[1] & 1; |
561 | for (k = 1; k <= sbr->n[0]; k++) |
562 | sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp]; |
563 | #if USE_FIXED |
564 | temp = (sbr->k[2] << 23) / sbr->kx[1]; |
565 | while (temp < 0x40000000) { |
566 | temp <<= 1; |
567 | nz++; |
568 | } |
569 | temp = fixed_log(temp - 0x80000000); |
570 | temp = (int)(((int64_t)temp * CONST_RECIP_LN2 + 0x20000000) >> 30); |
571 | temp = (((temp + 0x80) >> 8) + ((8 - nz) << 23)) * sbr->spectrum_params.bs_noise_bands; |
572 | |
573 | sbr->n_q = (temp + 0x400000) >> 23; |
574 | if (sbr->n_q < 1) |
575 | sbr->n_q = 1; |
576 | #else |
577 | sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands * |
578 | log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3 |
579 | #endif /* USE_FIXED */ |
580 | |
581 | if (sbr->n_q > 5) { |
582 | av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q); |
583 | return -1; |
584 | } |
585 | |
586 | sbr->f_tablenoise[0] = sbr->f_tablelow[0]; |
587 | temp = 0; |
588 | for (k = 1; k <= sbr->n_q; k++) { |
589 | temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k); |
590 | sbr->f_tablenoise[k] = sbr->f_tablelow[temp]; |
591 | } |
592 | |
593 | if (sbr_hf_calc_npatches(ac, sbr) < 0) |
594 | return -1; |
595 | |
596 | sbr_make_f_tablelim(sbr); |
597 | |
598 | sbr->data[0].f_indexnoise = 0; |
599 | sbr->data[1].f_indexnoise = 0; |
600 | |
601 | return 0; |
602 | } |
603 | |
604 | static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec, |
605 | int elements) |
606 | { |
607 | int i; |
608 | for (i = 0; i < elements; i++) { |
609 | vec[i] = get_bits1(gb); |
610 | } |
611 | } |
612 | |
613 | /** ceil(log2(index+1)) */ |
614 | static const int8_t ceil_log2[] = { |
615 | 0, 1, 2, 2, 3, 3, |
616 | }; |
617 | |
618 | static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr, |
619 | GetBitContext *gb, SBRData *ch_data) |
620 | { |
621 | int i; |
622 | int bs_pointer = 0; |
623 | // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots |
624 | int abs_bord_trail = 16; |
625 | int num_rel_lead, num_rel_trail; |
626 | unsigned bs_num_env_old = ch_data->bs_num_env; |
627 | |
628 | ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env]; |
629 | ch_data->bs_amp_res = sbr->bs_amp_res_header; |
630 | ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old]; |
631 | |
632 | switch (ch_data->bs_frame_class = get_bits(gb, 2)) { |
633 | case FIXFIX: |
634 | ch_data->bs_num_env = 1 << get_bits(gb, 2); |
635 | num_rel_lead = ch_data->bs_num_env - 1; |
636 | if (ch_data->bs_num_env == 1) |
637 | ch_data->bs_amp_res = 0; |
638 | |
639 | if (ch_data->bs_num_env > 4) { |
640 | av_log(ac->avctx, AV_LOG_ERROR, |
641 | "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n", |
642 | ch_data->bs_num_env); |
643 | return -1; |
644 | } |
645 | |
646 | ch_data->t_env[0] = 0; |
647 | ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail; |
648 | |
649 | abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) / |
650 | ch_data->bs_num_env; |
651 | for (i = 0; i < num_rel_lead; i++) |
652 | ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail; |
653 | |
654 | ch_data->bs_freq_res[1] = get_bits1(gb); |
655 | for (i = 1; i < ch_data->bs_num_env; i++) |
656 | ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1]; |
657 | break; |
658 | case FIXVAR: |
659 | abs_bord_trail += get_bits(gb, 2); |
660 | num_rel_trail = get_bits(gb, 2); |
661 | ch_data->bs_num_env = num_rel_trail + 1; |
662 | ch_data->t_env[0] = 0; |
663 | ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail; |
664 | |
665 | for (i = 0; i < num_rel_trail; i++) |
666 | ch_data->t_env[ch_data->bs_num_env - 1 - i] = |
667 | ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2; |
668 | |
669 | bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]); |
670 | |
671 | for (i = 0; i < ch_data->bs_num_env; i++) |
672 | ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb); |
673 | break; |
674 | case VARFIX: |
675 | ch_data->t_env[0] = get_bits(gb, 2); |
676 | num_rel_lead = get_bits(gb, 2); |
677 | ch_data->bs_num_env = num_rel_lead + 1; |
678 | ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail; |
679 | |
680 | for (i = 0; i < num_rel_lead; i++) |
681 | ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2; |
682 | |
683 | bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]); |
684 | |
685 | get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env); |
686 | break; |
687 | case VARVAR: |
688 | ch_data->t_env[0] = get_bits(gb, 2); |
689 | abs_bord_trail += get_bits(gb, 2); |
690 | num_rel_lead = get_bits(gb, 2); |
691 | num_rel_trail = get_bits(gb, 2); |
692 | ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1; |
693 | |
694 | if (ch_data->bs_num_env > 5) { |
695 | av_log(ac->avctx, AV_LOG_ERROR, |
696 | "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n", |
697 | ch_data->bs_num_env); |
698 | return -1; |
699 | } |
700 | |
701 | ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail; |
702 | |
703 | for (i = 0; i < num_rel_lead; i++) |
704 | ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2; |
705 | for (i = 0; i < num_rel_trail; i++) |
706 | ch_data->t_env[ch_data->bs_num_env - 1 - i] = |
707 | ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2; |
708 | |
709 | bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]); |
710 | |
711 | get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env); |
712 | break; |
713 | } |
714 | |
715 | av_assert0(bs_pointer >= 0); |
716 | if (bs_pointer > ch_data->bs_num_env + 1) { |
717 | av_log(ac->avctx, AV_LOG_ERROR, |
718 | "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n", |
719 | bs_pointer); |
720 | return -1; |
721 | } |
722 | |
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->avctx, AV_LOG_ERROR, "Not strictly monotone time borders\n"); |
726 | return -1; |
727 | } |
728 | } |
729 | |
730 | ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1; |
731 | |
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) { |
735 | int idx; |
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); |
740 | } else { // VARFIX |
741 | if (!bs_pointer) |
742 | idx = 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; |
747 | } |
748 | ch_data->t_q[1] = ch_data->t_env[idx]; |
749 | } |
750 | |
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; |
757 | |
758 | return 0; |
759 | } |
760 | |
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); |
766 | |
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]; |
776 | } |
777 | |
778 | /// Read how the envelope and noise floor data is delta coded |
779 | static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, |
780 | SBRData *ch_data) |
781 | { |
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); |
784 | } |
785 | |
786 | /// Read inverse filtering data |
787 | static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, |
788 | SBRData *ch_data) |
789 | { |
790 | int i; |
791 | |
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); |
795 | } |
796 | |
797 | static int read_sbr_envelope(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, |
798 | SBRData *ch_data, int ch) |
799 | { |
800 | int bits; |
801 | int i, j, k; |
802 | VLC_TYPE (*t_huff)[2], (*f_huff)[2]; |
803 | int t_lav, f_lav; |
804 | const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1; |
805 | const int odd = sbr->n[1] & 1; |
806 | |
807 | if (sbr->bs_coupling && ch) { |
808 | if (ch_data->bs_amp_res) { |
809 | bits = 5; |
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]; |
814 | } else { |
815 | bits = 6; |
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]; |
820 | } |
821 | } else { |
822 | if (ch_data->bs_amp_res) { |
823 | bits = 6; |
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]; |
828 | } else { |
829 | bits = 7; |
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]; |
834 | } |
835 | } |
836 | |
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_q[i + 1][j] = ch_data->env_facs_q[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav); |
843 | if (ch_data->env_facs_q[i + 1][j] > 127U) { |
844 | av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]); |
845 | return AVERROR_INVALIDDATA; |
846 | } |
847 | } |
848 | } else if (ch_data->bs_freq_res[i + 1]) { |
849 | for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) { |
850 | k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1] |
851 | ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav); |
852 | if (ch_data->env_facs_q[i + 1][j] > 127U) { |
853 | av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]); |
854 | return AVERROR_INVALIDDATA; |
855 | } |
856 | } |
857 | } else { |
858 | for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) { |
859 | k = j ? 2*j - odd : 0; // find k such that f_tablehigh[k] == f_tablelow[j] |
860 | ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav); |
861 | if (ch_data->env_facs_q[i + 1][j] > 127U) { |
862 | av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]); |
863 | return AVERROR_INVALIDDATA; |
864 | } |
865 | } |
866 | } |
867 | } else { |
868 | ch_data->env_facs_q[i + 1][0] = delta * get_bits(gb, bits); // bs_env_start_value_balance |
869 | for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) { |
870 | ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i + 1][j - 1] + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav); |
871 | if (ch_data->env_facs_q[i + 1][j] > 127U) { |
872 | av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]); |
873 | return AVERROR_INVALIDDATA; |
874 | } |
875 | } |
876 | } |
877 | } |
878 | |
879 | //assign 0th elements of env_facs_q from last elements |
880 | memcpy(ch_data->env_facs_q[0], ch_data->env_facs_q[ch_data->bs_num_env], |
881 | sizeof(ch_data->env_facs_q[0])); |
882 | |
883 | return 0; |
884 | } |
885 | |
886 | static int read_sbr_noise(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, |
887 | SBRData *ch_data, int ch) |
888 | { |
889 | int i, j; |
890 | VLC_TYPE (*t_huff)[2], (*f_huff)[2]; |
891 | int t_lav, f_lav; |
892 | int delta = (ch == 1 && sbr->bs_coupling == 1) + 1; |
893 | |
894 | if (sbr->bs_coupling && ch) { |
895 | t_huff = vlc_sbr[T_HUFFMAN_NOISE_BAL_3_0DB].table; |
896 | t_lav = vlc_sbr_lav[T_HUFFMAN_NOISE_BAL_3_0DB]; |
897 | f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table; |
898 | f_lav = vlc_sbr_lav[F_HUFFMAN_ENV_BAL_3_0DB]; |
899 | } else { |
900 | t_huff = vlc_sbr[T_HUFFMAN_NOISE_3_0DB].table; |
901 | t_lav = vlc_sbr_lav[T_HUFFMAN_NOISE_3_0DB]; |
902 | f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table; |
903 | f_lav = vlc_sbr_lav[F_HUFFMAN_ENV_3_0DB]; |
904 | } |
905 | |
906 | for (i = 0; i < ch_data->bs_num_noise; i++) { |
907 | if (ch_data->bs_df_noise[i]) { |
908 | for (j = 0; j < sbr->n_q; j++) { |
909 | ch_data->noise_facs_q[i + 1][j] = ch_data->noise_facs_q[i][j] + delta * (get_vlc2(gb, t_huff, 9, 2) - t_lav); |
910 | if (ch_data->noise_facs_q[i + 1][j] > 30U) { |
911 | av_log(ac->avctx, AV_LOG_ERROR, "noise_facs_q %d is invalid\n", ch_data->noise_facs_q[i + 1][j]); |
912 | return AVERROR_INVALIDDATA; |
913 | } |
914 | } |
915 | } else { |
916 | ch_data->noise_facs_q[i + 1][0] = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level |
917 | for (j = 1; j < sbr->n_q; j++) { |
918 | ch_data->noise_facs_q[i + 1][j] = ch_data->noise_facs_q[i + 1][j - 1] + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav); |
919 | if (ch_data->noise_facs_q[i + 1][j] > 30U) { |
920 | av_log(ac->avctx, AV_LOG_ERROR, "noise_facs_q %d is invalid\n", ch_data->noise_facs_q[i + 1][j]); |
921 | return AVERROR_INVALIDDATA; |
922 | } |
923 | } |
924 | } |
925 | } |
926 | |
927 | //assign 0th elements of noise_facs_q from last elements |
928 | memcpy(ch_data->noise_facs_q[0], ch_data->noise_facs_q[ch_data->bs_num_noise], |
929 | sizeof(ch_data->noise_facs_q[0])); |
930 | return 0; |
931 | } |
932 | |
933 | static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr, |
934 | GetBitContext *gb, |
935 | int bs_extension_id, int *num_bits_left) |
936 | { |
937 | switch (bs_extension_id) { |
938 | case EXTENSION_ID_PS: |
939 | if (!ac->oc[1].m4ac.ps) { |
940 | av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n"); |
941 | skip_bits_long(gb, *num_bits_left); // bs_fill_bits |
942 | *num_bits_left = 0; |
943 | } else { |
944 | *num_bits_left -= AAC_RENAME(ff_ps_read_data)(ac->avctx, gb, &sbr->ps, *num_bits_left); |
945 | ac->avctx->profile = FF_PROFILE_AAC_HE_V2; |
946 | } |
947 | break; |
948 | default: |
949 | // some files contain 0-padding |
950 | if (bs_extension_id || *num_bits_left > 16 || show_bits(gb, *num_bits_left)) |
951 | avpriv_request_sample(ac->avctx, "Reserved SBR extensions"); |
952 | skip_bits_long(gb, *num_bits_left); // bs_fill_bits |
953 | *num_bits_left = 0; |
954 | break; |
955 | } |
956 | } |
957 | |
958 | static int read_sbr_single_channel_element(AACContext *ac, |
959 | SpectralBandReplication *sbr, |
960 | GetBitContext *gb) |
961 | { |
962 | int ret; |
963 | |
964 | if (get_bits1(gb)) // bs_data_extra |
965 | skip_bits(gb, 4); // bs_reserved |
966 | |
967 | if (read_sbr_grid(ac, sbr, gb, &sbr->data[0])) |
968 | return -1; |
969 | read_sbr_dtdf(sbr, gb, &sbr->data[0]); |
970 | read_sbr_invf(sbr, gb, &sbr->data[0]); |
971 | if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0) |
972 | return ret; |
973 | if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0) |
974 | return ret; |
975 | |
976 | if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb))) |
977 | get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]); |
978 | |
979 | return 0; |
980 | } |
981 | |
982 | static int read_sbr_channel_pair_element(AACContext *ac, |
983 | SpectralBandReplication *sbr, |
984 | GetBitContext *gb) |
985 | { |
986 | int ret; |
987 | |
988 | if (get_bits1(gb)) // bs_data_extra |
989 | skip_bits(gb, 8); // bs_reserved |
990 | |
991 | if ((sbr->bs_coupling = get_bits1(gb))) { |
992 | if (read_sbr_grid(ac, sbr, gb, &sbr->data[0])) |
993 | return -1; |
994 | copy_sbr_grid(&sbr->data[1], &sbr->data[0]); |
995 | read_sbr_dtdf(sbr, gb, &sbr->data[0]); |
996 | read_sbr_dtdf(sbr, gb, &sbr->data[1]); |
997 | read_sbr_invf(sbr, gb, &sbr->data[0]); |
998 | memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0])); |
999 | memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0])); |
1000 | if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0) |
1001 | return ret; |
1002 | if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0) |
1003 | return ret; |
1004 | if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0) |
1005 | return ret; |
1006 | if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0) |
1007 | return ret; |
1008 | } else { |
1009 | if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) || |
1010 | read_sbr_grid(ac, sbr, gb, &sbr->data[1])) |
1011 | return -1; |
1012 | read_sbr_dtdf(sbr, gb, &sbr->data[0]); |
1013 | read_sbr_dtdf(sbr, gb, &sbr->data[1]); |
1014 | read_sbr_invf(sbr, gb, &sbr->data[0]); |
1015 | read_sbr_invf(sbr, gb, &sbr->data[1]); |
1016 | if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0) |
1017 | return ret; |
1018 | if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0) |
1019 | return ret; |
1020 | if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0) |
1021 | return ret; |
1022 | if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0) |
1023 | return ret; |
1024 | } |
1025 | |
1026 | if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb))) |
1027 | get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]); |
1028 | if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb))) |
1029 | get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]); |
1030 | |
1031 | return 0; |
1032 | } |
1033 | |
1034 | static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr, |
1035 | GetBitContext *gb, int id_aac) |
1036 | { |
1037 | unsigned int cnt = get_bits_count(gb); |
1038 | |
1039 | sbr->id_aac = id_aac; |
1040 | sbr->ready_for_dequant = 1; |
1041 | |
1042 | if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) { |
1043 | if (read_sbr_single_channel_element(ac, sbr, gb)) { |
1044 | sbr_turnoff(sbr); |
1045 | return get_bits_count(gb) - cnt; |
1046 | } |
1047 | } else if (id_aac == TYPE_CPE) { |
1048 | if (read_sbr_channel_pair_element(ac, sbr, gb)) { |
1049 | sbr_turnoff(sbr); |
1050 | return get_bits_count(gb) - cnt; |
1051 | } |
1052 | } else { |
1053 | av_log(ac->avctx, AV_LOG_ERROR, |
1054 | "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac); |
1055 | sbr_turnoff(sbr); |
1056 | return get_bits_count(gb) - cnt; |
1057 | } |
1058 | if (get_bits1(gb)) { // bs_extended_data |
1059 | int num_bits_left = get_bits(gb, 4); // bs_extension_size |
1060 | if (num_bits_left == 15) |
1061 | num_bits_left += get_bits(gb, 8); // bs_esc_count |
1062 | |
1063 | num_bits_left <<= 3; |
1064 | while (num_bits_left > 7) { |
1065 | num_bits_left -= 2; |
1066 | read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id |
1067 | } |
1068 | if (num_bits_left < 0) { |
1069 | av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n"); |
1070 | } |
1071 | if (num_bits_left > 0) |
1072 | skip_bits(gb, num_bits_left); |
1073 | } |
1074 | |
1075 | return get_bits_count(gb) - cnt; |
1076 | } |
1077 | |
1078 | static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr) |
1079 | { |
1080 | int err; |
1081 | err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params); |
1082 | if (err >= 0) |
1083 | err = sbr_make_f_derived(ac, sbr); |
1084 | if (err < 0) { |
1085 | av_log(ac->avctx, AV_LOG_ERROR, |
1086 | "SBR reset failed. Switching SBR to pure upsampling mode.\n"); |
1087 | sbr_turnoff(sbr); |
1088 | } |
1089 | } |
1090 | |
1091 | /** |
1092 | * Decode Spectral Band Replication extension data; reference: table 4.55. |
1093 | * |
1094 | * @param crc flag indicating the presence of CRC checksum |
1095 | * @param cnt length of TYPE_FIL syntactic element in bytes |
1096 | * |
1097 | * @return Returns number of bytes consumed from the TYPE_FIL element. |
1098 | */ |
1099 | int AAC_RENAME(ff_decode_sbr_extension)(AACContext *ac, SpectralBandReplication *sbr, |
1100 | GetBitContext *gb_host, int crc, int cnt, int id_aac) |
1101 | { |
1102 | unsigned int num_sbr_bits = 0, num_align_bits; |
1103 | unsigned bytes_read; |
1104 | GetBitContext gbc = *gb_host, *gb = &gbc; |
1105 | skip_bits_long(gb_host, cnt*8 - 4); |
1106 | |
1107 | sbr->reset = 0; |
1108 | |
1109 | if (!sbr->sample_rate) |
1110 | sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support |
1111 | if (!ac->oc[1].m4ac.ext_sample_rate) |
1112 | ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate; |
1113 | |
1114 | if (crc) { |
1115 | skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check |
1116 | num_sbr_bits += 10; |
1117 | } |
1118 | |
1119 | //Save some state from the previous frame. |
1120 | sbr->kx[0] = sbr->kx[1]; |
1121 | sbr->m[0] = sbr->m[1]; |
1122 | sbr->kx_and_m_pushed = 1; |
1123 | |
1124 | num_sbr_bits++; |
1125 | if (get_bits1(gb)) // bs_header_flag |
1126 | num_sbr_bits += read_sbr_header(sbr, gb); |
1127 | |
1128 | if (sbr->reset) |
1129 | sbr_reset(ac, sbr); |
1130 | |
1131 | if (sbr->start) |
1132 | num_sbr_bits += read_sbr_data(ac, sbr, gb, id_aac); |
1133 | |
1134 | num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7; |
1135 | bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3); |
1136 | |
1137 | if (bytes_read > cnt) { |
1138 | av_log(ac->avctx, AV_LOG_ERROR, |
1139 | "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read); |
1140 | sbr_turnoff(sbr); |
1141 | } |
1142 | return cnt; |
1143 | } |
1144 | |
1145 | /** |
1146 | * Analysis QMF Bank (14496-3 sp04 p206) |
1147 | * |
1148 | * @param x pointer to the beginning of the first sample window |
1149 | * @param W array of complex-valued samples split into subbands |
1150 | */ |
1151 | #ifndef sbr_qmf_analysis |
1152 | #if USE_FIXED |
1153 | static void sbr_qmf_analysis(AVFixedDSPContext *dsp, FFTContext *mdct, |
1154 | #else |
1155 | static void sbr_qmf_analysis(AVFloatDSPContext *dsp, FFTContext *mdct, |
1156 | #endif /* USE_FIXED */ |
1157 | SBRDSPContext *sbrdsp, const INTFLOAT *in, INTFLOAT *x, |
1158 | INTFLOAT z[320], INTFLOAT W[2][32][32][2], int buf_idx) |
1159 | { |
1160 | int i; |
1161 | #if USE_FIXED |
1162 | int j; |
1163 | #endif |
1164 | memcpy(x , x+1024, (320-32)*sizeof(x[0])); |
1165 | memcpy(x+288, in, 1024*sizeof(x[0])); |
1166 | for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames |
1167 | // are not supported |
1168 | dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320); |
1169 | sbrdsp->sum64x5(z); |
1170 | sbrdsp->qmf_pre_shuffle(z); |
1171 | #if USE_FIXED |
1172 | for (j = 64; j < 128; j++) { |
1173 | if (z[j] > 1<<24) { |
1174 | av_log(NULL, AV_LOG_WARNING, |
1175 | "sbr_qmf_analysis: value %09d too large, setting to %09d\n", |
1176 | z[j], 1<<24); |
1177 | z[j] = 1<<24; |
1178 | } else if (z[j] < -(1<<24)) { |
1179 | av_log(NULL, AV_LOG_WARNING, |
1180 | "sbr_qmf_analysis: value %09d too small, setting to %09d\n", |
1181 | z[j], -(1<<24)); |
1182 | z[j] = -(1<<24); |
1183 | } |
1184 | } |
1185 | #endif |
1186 | mdct->imdct_half(mdct, z, z+64); |
1187 | sbrdsp->qmf_post_shuffle(W[buf_idx][i], z); |
1188 | x += 32; |
1189 | } |
1190 | } |
1191 | #endif |
1192 | |
1193 | /** |
1194 | * Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank |
1195 | * (14496-3 sp04 p206) |
1196 | */ |
1197 | #ifndef sbr_qmf_synthesis |
1198 | static void sbr_qmf_synthesis(FFTContext *mdct, |
1199 | #if USE_FIXED |
1200 | SBRDSPContext *sbrdsp, AVFixedDSPContext *dsp, |
1201 | #else |
1202 | SBRDSPContext *sbrdsp, AVFloatDSPContext *dsp, |
1203 | #endif /* USE_FIXED */ |
1204 | INTFLOAT *out, INTFLOAT X[2][38][64], |
1205 | INTFLOAT mdct_buf[2][64], |
1206 | INTFLOAT *v0, int *v_off, const unsigned int div) |
1207 | { |
1208 | int i, n; |
1209 | const INTFLOAT *sbr_qmf_window = div ? sbr_qmf_window_ds : sbr_qmf_window_us; |
1210 | const int step = 128 >> div; |
1211 | INTFLOAT *v; |
1212 | for (i = 0; i < 32; i++) { |
1213 | if (*v_off < step) { |
1214 | int saved_samples = (1280 - 128) >> div; |
1215 | memcpy(&v0[SBR_SYNTHESIS_BUF_SIZE - saved_samples], v0, saved_samples * sizeof(INTFLOAT)); |
1216 | *v_off = SBR_SYNTHESIS_BUF_SIZE - saved_samples - step; |
1217 | } else { |
1218 | *v_off -= step; |
1219 | } |
1220 | v = v0 + *v_off; |
1221 | if (div) { |
1222 | for (n = 0; n < 32; n++) { |
1223 | X[0][i][ n] = -X[0][i][n]; |
1224 | X[0][i][32+n] = X[1][i][31-n]; |
1225 | } |
1226 | mdct->imdct_half(mdct, mdct_buf[0], X[0][i]); |
1227 | sbrdsp->qmf_deint_neg(v, mdct_buf[0]); |
1228 | } else { |
1229 | sbrdsp->neg_odd_64(X[1][i]); |
1230 | mdct->imdct_half(mdct, mdct_buf[0], X[0][i]); |
1231 | mdct->imdct_half(mdct, mdct_buf[1], X[1][i]); |
1232 | sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]); |
1233 | } |
1234 | dsp->vector_fmul (out, v , sbr_qmf_window , 64 >> div); |
1235 | dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div); |
1236 | dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div); |
1237 | dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div); |
1238 | dsp->vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div); |
1239 | dsp->vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div); |
1240 | dsp->vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div); |
1241 | dsp->vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div); |
1242 | dsp->vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div); |
1243 | dsp->vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div); |
1244 | out += 64 >> div; |
1245 | } |
1246 | } |
1247 | #endif |
1248 | |
1249 | /// Generate the subband filtered lowband |
1250 | static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr, |
1251 | INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], |
1252 | int buf_idx) |
1253 | { |
1254 | int i, k; |
1255 | const int t_HFGen = 8; |
1256 | const int i_f = 32; |
1257 | memset(X_low, 0, 32*sizeof(*X_low)); |
1258 | for (k = 0; k < sbr->kx[1]; k++) { |
1259 | for (i = t_HFGen; i < i_f + t_HFGen; i++) { |
1260 | X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0]; |
1261 | X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1]; |
1262 | } |
1263 | } |
1264 | buf_idx = 1-buf_idx; |
1265 | for (k = 0; k < sbr->kx[0]; k++) { |
1266 | for (i = 0; i < t_HFGen; i++) { |
1267 | X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0]; |
1268 | X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1]; |
1269 | } |
1270 | } |
1271 | return 0; |
1272 | } |
1273 | |
1274 | /// High Frequency Generator (14496-3 sp04 p215) |
1275 | static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr, |
1276 | INTFLOAT X_high[64][40][2], const INTFLOAT X_low[32][40][2], |
1277 | const INTFLOAT (*alpha0)[2], const INTFLOAT (*alpha1)[2], |
1278 | const INTFLOAT bw_array[5], const uint8_t *t_env, |
1279 | int bs_num_env) |
1280 | { |
1281 | int j, x; |
1282 | int g = 0; |
1283 | int k = sbr->kx[1]; |
1284 | for (j = 0; j < sbr->num_patches; j++) { |
1285 | for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) { |
1286 | const int p = sbr->patch_start_subband[j] + x; |
1287 | while (g <= sbr->n_q && k >= sbr->f_tablenoise[g]) |
1288 | g++; |
1289 | g--; |
1290 | |
1291 | if (g < 0) { |
1292 | av_log(ac->avctx, AV_LOG_ERROR, |
1293 | "ERROR : no subband found for frequency %d\n", k); |
1294 | return -1; |
1295 | } |
1296 | |
1297 | sbr->dsp.hf_gen(X_high[k] + ENVELOPE_ADJUSTMENT_OFFSET, |
1298 | X_low[p] + ENVELOPE_ADJUSTMENT_OFFSET, |
1299 | alpha0[p], alpha1[p], bw_array[g], |
1300 | 2 * t_env[0], 2 * t_env[bs_num_env]); |
1301 | } |
1302 | } |
1303 | if (k < sbr->m[1] + sbr->kx[1]) |
1304 | memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high)); |
1305 | |
1306 | return 0; |
1307 | } |
1308 | |
1309 | /// Generate the subband filtered lowband |
1310 | static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64], |
1311 | const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2], |
1312 | const INTFLOAT X_low[32][40][2], int ch) |
1313 | { |
1314 | int k, i; |
1315 | const int i_f = 32; |
1316 | const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0); |
1317 | memset(X, 0, 2*sizeof(*X)); |
1318 | for (k = 0; k < sbr->kx[0]; k++) { |
1319 | for (i = 0; i < i_Temp; i++) { |
1320 | X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0]; |
1321 | X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1]; |
1322 | } |
1323 | } |
1324 | for (; k < sbr->kx[0] + sbr->m[0]; k++) { |
1325 | for (i = 0; i < i_Temp; i++) { |
1326 | X[0][i][k] = Y0[i + i_f][k][0]; |
1327 | X[1][i][k] = Y0[i + i_f][k][1]; |
1328 | } |
1329 | } |
1330 | |
1331 | for (k = 0; k < sbr->kx[1]; k++) { |
1332 | for (i = i_Temp; i < 38; i++) { |
1333 | X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0]; |
1334 | X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1]; |
1335 | } |
1336 | } |
1337 | for (; k < sbr->kx[1] + sbr->m[1]; k++) { |
1338 | for (i = i_Temp; i < i_f; i++) { |
1339 | X[0][i][k] = Y1[i][k][0]; |
1340 | X[1][i][k] = Y1[i][k][1]; |
1341 | } |
1342 | } |
1343 | return 0; |
1344 | } |
1345 | |
1346 | /** High Frequency Adjustment (14496-3 sp04 p217) and Mapping |
1347 | * (14496-3 sp04 p217) |
1348 | */ |
1349 | static int sbr_mapping(AACContext *ac, SpectralBandReplication *sbr, |
1350 | SBRData *ch_data, int e_a[2]) |
1351 | { |
1352 | int e, i, m; |
1353 | |
1354 | memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1])); |
1355 | for (e = 0; e < ch_data->bs_num_env; e++) { |
1356 | const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]]; |
1357 | uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow; |
1358 | int k; |
1359 | |
1360 | if (sbr->kx[1] != table[0]) { |
1361 | av_log(ac->avctx, AV_LOG_ERROR, "kx != f_table{high,low}[0]. " |
1362 | "Derived frequency tables were not regenerated.\n"); |
1363 | sbr_turnoff(sbr); |
1364 | return AVERROR_BUG; |
1365 | } |
1366 | for (i = 0; i < ilim; i++) |
1367 | for (m = table[i]; m < table[i + 1]; m++) |
1368 | sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i]; |
1369 | |
1370 | // ch_data->bs_num_noise > 1 => 2 noise floors |
1371 | k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]); |
1372 | for (i = 0; i < sbr->n_q; i++) |
1373 | for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++) |
1374 | sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i]; |
1375 | |
1376 | for (i = 0; i < sbr->n[1]; i++) { |
1377 | if (ch_data->bs_add_harmonic_flag) { |
1378 | const unsigned int m_midpoint = |
1379 | (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1; |
1380 | |
1381 | ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] * |
1382 | (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1)); |
1383 | } |
1384 | } |
1385 | |
1386 | for (i = 0; i < ilim; i++) { |
1387 | int additional_sinusoid_present = 0; |
1388 | for (m = table[i]; m < table[i + 1]; m++) { |
1389 | if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) { |
1390 | additional_sinusoid_present = 1; |
1391 | break; |
1392 | } |
1393 | } |
1394 | memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present, |
1395 | (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0])); |
1396 | } |
1397 | } |
1398 | |
1399 | memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0])); |
1400 | return 0; |
1401 | } |
1402 | |
1403 | /// Estimation of current envelope (14496-3 sp04 p218) |
1404 | static void sbr_env_estimate(AAC_FLOAT (*e_curr)[48], INTFLOAT X_high[64][40][2], |
1405 | SpectralBandReplication *sbr, SBRData *ch_data) |
1406 | { |
1407 | int e, m; |
1408 | int kx1 = sbr->kx[1]; |
1409 | |
1410 | if (sbr->bs_interpol_freq) { |
1411 | for (e = 0; e < ch_data->bs_num_env; e++) { |
1412 | #if USE_FIXED |
1413 | const SoftFloat recip_env_size = av_int2sf(0x20000000 / (ch_data->t_env[e + 1] - ch_data->t_env[e]), 30); |
1414 | #else |
1415 | const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]); |
1416 | #endif /* USE_FIXED */ |
1417 | int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1418 | int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1419 | |
1420 | for (m = 0; m < sbr->m[1]; m++) { |
1421 | AAC_FLOAT sum = sbr->dsp.sum_square(X_high[m+kx1] + ilb, iub - ilb); |
1422 | #if USE_FIXED |
1423 | e_curr[e][m] = av_mul_sf(sum, recip_env_size); |
1424 | #else |
1425 | e_curr[e][m] = sum * recip_env_size; |
1426 | #endif /* USE_FIXED */ |
1427 | } |
1428 | } |
1429 | } else { |
1430 | int k, p; |
1431 | |
1432 | for (e = 0; e < ch_data->bs_num_env; e++) { |
1433 | const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]); |
1434 | int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1435 | int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1436 | const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow; |
1437 | |
1438 | for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) { |
1439 | #if USE_FIXED |
1440 | SoftFloat sum = FLOAT_0; |
1441 | const SoftFloat den = av_int2sf(0x20000000 / (env_size * (table[p + 1] - table[p])), 29); |
1442 | for (k = table[p]; k < table[p + 1]; k++) { |
1443 | sum = av_add_sf(sum, sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb)); |
1444 | } |
1445 | sum = av_mul_sf(sum, den); |
1446 | #else |
1447 | float sum = 0.0f; |
1448 | const int den = env_size * (table[p + 1] - table[p]); |
1449 | |
1450 | for (k = table[p]; k < table[p + 1]; k++) { |
1451 | sum += sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb); |
1452 | } |
1453 | sum /= den; |
1454 | #endif /* USE_FIXED */ |
1455 | for (k = table[p]; k < table[p + 1]; k++) { |
1456 | e_curr[e][k - kx1] = sum; |
1457 | } |
1458 | } |
1459 | } |
1460 | } |
1461 | } |
1462 | |
1463 | void AAC_RENAME(ff_sbr_apply)(AACContext *ac, SpectralBandReplication *sbr, int id_aac, |
1464 | INTFLOAT* L, INTFLOAT* R) |
1465 | { |
1466 | int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate; |
1467 | int ch; |
1468 | int nch = (id_aac == TYPE_CPE) ? 2 : 1; |
1469 | int err; |
1470 | |
1471 | if (id_aac != sbr->id_aac) { |
1472 | av_log(ac->avctx, id_aac == TYPE_LFE ? AV_LOG_VERBOSE : AV_LOG_WARNING, |
1473 | "element type mismatch %d != %d\n", id_aac, sbr->id_aac); |
1474 | sbr_turnoff(sbr); |
1475 | } |
1476 | |
1477 | if (sbr->start && !sbr->ready_for_dequant) { |
1478 | av_log(ac->avctx, AV_LOG_ERROR, |
1479 | "No quantized data read for sbr_dequant.\n"); |
1480 | sbr_turnoff(sbr); |
1481 | } |
1482 | |
1483 | if (!sbr->kx_and_m_pushed) { |
1484 | sbr->kx[0] = sbr->kx[1]; |
1485 | sbr->m[0] = sbr->m[1]; |
1486 | } else { |
1487 | sbr->kx_and_m_pushed = 0; |
1488 | } |
1489 | |
1490 | if (sbr->start) { |
1491 | sbr_dequant(sbr, id_aac); |
1492 | sbr->ready_for_dequant = 0; |
1493 | } |
1494 | for (ch = 0; ch < nch; ch++) { |
1495 | /* decode channel */ |
1496 | sbr_qmf_analysis(ac->fdsp, &sbr->mdct_ana, &sbr->dsp, ch ? R : L, sbr->data[ch].analysis_filterbank_samples, |
1497 | (INTFLOAT*)sbr->qmf_filter_scratch, |
1498 | sbr->data[ch].W, sbr->data[ch].Ypos); |
1499 | sbr->c.sbr_lf_gen(ac, sbr, sbr->X_low, |
1500 | (const INTFLOAT (*)[32][32][2]) sbr->data[ch].W, |
1501 | sbr->data[ch].Ypos); |
1502 | sbr->data[ch].Ypos ^= 1; |
1503 | if (sbr->start) { |
1504 | sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1, |
1505 | (const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]); |
1506 | sbr_chirp(sbr, &sbr->data[ch]); |
1507 | av_assert0(sbr->data[ch].bs_num_env > 0); |
1508 | sbr_hf_gen(ac, sbr, sbr->X_high, |
1509 | (const INTFLOAT (*)[40][2]) sbr->X_low, |
1510 | (const INTFLOAT (*)[2]) sbr->alpha0, |
1511 | (const INTFLOAT (*)[2]) sbr->alpha1, |
1512 | sbr->data[ch].bw_array, sbr->data[ch].t_env, |
1513 | sbr->data[ch].bs_num_env); |
1514 | |
1515 | // hf_adj |
1516 | err = sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a); |
1517 | if (!err) { |
1518 | sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]); |
1519 | sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a); |
1520 | sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos], |
1521 | (const INTFLOAT (*)[40][2]) sbr->X_high, |
1522 | sbr, &sbr->data[ch], |
1523 | sbr->data[ch].e_a); |
1524 | } |
1525 | } |
1526 | |
1527 | /* synthesis */ |
1528 | sbr->c.sbr_x_gen(sbr, sbr->X[ch], |
1529 | (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos], |
1530 | (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[ sbr->data[ch].Ypos], |
1531 | (const INTFLOAT (*)[40][2]) sbr->X_low, ch); |
1532 | } |
1533 | |
1534 | if (ac->oc[1].m4ac.ps == 1) { |
1535 | if (sbr->ps.start) { |
1536 | AAC_RENAME(ff_ps_apply)(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]); |
1537 | } else { |
1538 | memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0])); |
1539 | } |
1540 | nch = 2; |
1541 | } |
1542 | |
1543 | sbr_qmf_synthesis(&sbr->mdct, &sbr->dsp, ac->fdsp, |
1544 | L, sbr->X[0], sbr->qmf_filter_scratch, |
1545 | sbr->data[0].synthesis_filterbank_samples, |
1546 | &sbr->data[0].synthesis_filterbank_samples_offset, |
1547 | downsampled); |
1548 | if (nch == 2) |
1549 | sbr_qmf_synthesis(&sbr->mdct, &sbr->dsp, ac->fdsp, |
1550 | R, sbr->X[1], sbr->qmf_filter_scratch, |
1551 | sbr->data[1].synthesis_filterbank_samples, |
1552 | &sbr->data[1].synthesis_filterbank_samples_offset, |
1553 | downsampled); |
1554 | } |
1555 | |
1556 | static void aacsbr_func_ptr_init(AACSBRContext *c) |
1557 | { |
1558 | c->sbr_lf_gen = sbr_lf_gen; |
1559 | c->sbr_hf_assemble = sbr_hf_assemble; |
1560 | c->sbr_x_gen = sbr_x_gen; |
1561 | c->sbr_hf_inverse_filter = sbr_hf_inverse_filter; |
1562 | |
1563 | #if !USE_FIXED |
1564 | if(ARCH_MIPS) |
1565 | ff_aacsbr_func_ptr_init_mips(c); |
1566 | #endif |
1567 | } |
1568 |