Mercurial > libavcodec.hg
annotate aac.c @ 7891:13ee9bb85721 libavcodec
Zero 'idx' for each iteration of the coupling gain loop and as it is only used
within this loop, we can move its declaration there too. This fixes bitstream
desync when decoding streams containing CCEs.
Based on a patch by Alex Converse (alex converse gmail com)
author | superdump |
---|---|
date | Thu, 18 Sep 2008 16:02:51 +0000 |
parents | 20dd4e5e5aa6 |
children | 8fd8f23be794 |
rev | line source |
---|---|
7501 | 1 /* |
2 * AAC decoder | |
3 * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org ) | |
4 * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com ) | |
5 * | |
6 * This file is part of FFmpeg. | |
7 * | |
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. | |
12 * | |
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. | |
17 * | |
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 | |
21 */ | |
22 | |
23 /** | |
24 * @file aac.c | |
25 * AAC decoder | |
26 * @author Oded Shimon ( ods15 ods15 dyndns org ) | |
27 * @author Maxim Gavrilov ( maxim.gavrilov gmail com ) | |
28 */ | |
29 | |
30 /* | |
31 * supported tools | |
32 * | |
33 * Support? Name | |
34 * N (code in SoC repo) gain control | |
35 * Y block switching | |
36 * Y window shapes - standard | |
37 * N window shapes - Low Delay | |
38 * Y filterbank - standard | |
39 * N (code in SoC repo) filterbank - Scalable Sample Rate | |
40 * Y Temporal Noise Shaping | |
41 * N (code in SoC repo) Long Term Prediction | |
42 * Y intensity stereo | |
43 * Y channel coupling | |
44 * N frequency domain prediction | |
45 * Y Perceptual Noise Substitution | |
46 * Y Mid/Side stereo | |
47 * N Scalable Inverse AAC Quantization | |
48 * N Frequency Selective Switch | |
49 * N upsampling filter | |
50 * Y quantization & coding - AAC | |
51 * N quantization & coding - TwinVQ | |
52 * N quantization & coding - BSAC | |
53 * N AAC Error Resilience tools | |
54 * N Error Resilience payload syntax | |
55 * N Error Protection tool | |
56 * N CELP | |
57 * N Silence Compression | |
58 * N HVXC | |
59 * N HVXC 4kbits/s VR | |
60 * N Structured Audio tools | |
61 * N Structured Audio Sample Bank Format | |
62 * N MIDI | |
63 * N Harmonic and Individual Lines plus Noise | |
64 * N Text-To-Speech Interface | |
65 * N (in progress) Spectral Band Replication | |
66 * Y (not in this code) Layer-1 | |
67 * Y (not in this code) Layer-2 | |
68 * Y (not in this code) Layer-3 | |
69 * N SinuSoidal Coding (Transient, Sinusoid, Noise) | |
70 * N (planned) Parametric Stereo | |
71 * N Direct Stream Transfer | |
72 * | |
73 * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication. | |
74 * - HE AAC v2 comprises LC AAC with Spectral Band Replication and | |
75 Parametric Stereo. | |
76 */ | |
77 | |
78 | |
79 #include "avcodec.h" | |
80 #include "bitstream.h" | |
81 #include "dsputil.h" | |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
82 #include "lpc.h" |
7501 | 83 |
84 #include "aac.h" | |
85 #include "aactab.h" | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
86 #include "aacdectab.h" |
7501 | 87 #include "mpeg4audio.h" |
88 | |
89 #include <assert.h> | |
90 #include <errno.h> | |
91 #include <math.h> | |
92 #include <string.h> | |
93 | |
94 static VLC vlc_scalefactors; | |
95 static VLC vlc_spectral[11]; | |
96 | |
97 | |
7539 | 98 /** |
7578 | 99 * Configure output channel order based on the current program configuration element. |
100 * | |
101 * @param che_pos current channel position configuration | |
102 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
103 * | |
104 * @return Returns error status. 0 - OK, !0 - error | |
105 */ | |
106 static int output_configure(AACContext *ac, enum ChannelPosition che_pos[4][MAX_ELEM_ID], | |
107 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]) { | |
108 AVCodecContext *avctx = ac->avccontext; | |
109 int i, type, channels = 0; | |
110 | |
111 if(!memcmp(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]))) | |
112 return 0; /* no change */ | |
113 | |
114 memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
115 | |
116 /* Allocate or free elements depending on if they are in the | |
117 * current program configuration. | |
118 * | |
119 * Set up default 1:1 output mapping. | |
120 * | |
121 * For a 5.1 stream the output order will be: | |
7633
bf34cb99da5b
The comment about channel order for AAC 5.1 audio was not correct, fix it.
andoma
parents:
7632
diff
changeset
|
122 * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ] |
7578 | 123 */ |
124 | |
125 for(i = 0; i < MAX_ELEM_ID; i++) { | |
126 for(type = 0; type < 4; type++) { | |
127 if(che_pos[type][i]) { | |
128 if(!ac->che[type][i] && !(ac->che[type][i] = av_mallocz(sizeof(ChannelElement)))) | |
129 return AVERROR(ENOMEM); | |
130 if(type != TYPE_CCE) { | |
131 ac->output_data[channels++] = ac->che[type][i]->ch[0].ret; | |
132 if(type == TYPE_CPE) { | |
133 ac->output_data[channels++] = ac->che[type][i]->ch[1].ret; | |
134 } | |
135 } | |
136 } else | |
137 av_freep(&ac->che[type][i]); | |
138 } | |
139 } | |
140 | |
141 avctx->channels = channels; | |
142 return 0; | |
143 } | |
144 | |
145 /** | |
7539 | 146 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit. |
147 * | |
148 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present. | |
149 * @param sce_map mono (Single Channel Element) map | |
150 * @param type speaker type/position for these channels | |
151 */ | |
152 static void decode_channel_map(enum ChannelPosition *cpe_map, | |
153 enum ChannelPosition *sce_map, enum ChannelPosition type, GetBitContext * gb, int n) { | |
154 while(n--) { | |
155 enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map | |
156 map[get_bits(gb, 4)] = type; | |
157 } | |
158 } | |
159 | |
160 /** | |
161 * Decode program configuration element; reference: table 4.2. | |
162 * | |
163 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
164 * | |
165 * @return Returns error status. 0 - OK, !0 - error | |
166 */ | |
167 static int decode_pce(AACContext * ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], | |
168 GetBitContext * gb) { | |
169 int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc; | |
170 | |
171 skip_bits(gb, 2); // object_type | |
172 | |
173 ac->m4ac.sampling_index = get_bits(gb, 4); | |
174 if(ac->m4ac.sampling_index > 11) { | |
175 av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); | |
176 return -1; | |
177 } | |
178 ac->m4ac.sample_rate = ff_mpeg4audio_sample_rates[ac->m4ac.sampling_index]; | |
7501 | 179 num_front = get_bits(gb, 4); |
180 num_side = get_bits(gb, 4); | |
181 num_back = get_bits(gb, 4); | |
182 num_lfe = get_bits(gb, 2); | |
183 num_assoc_data = get_bits(gb, 3); | |
184 num_cc = get_bits(gb, 4); | |
185 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
186 if (get_bits1(gb)) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
187 skip_bits(gb, 4); // mono_mixdown_tag |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
188 if (get_bits1(gb)) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
189 skip_bits(gb, 4); // stereo_mixdown_tag |
7501 | 190 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
191 if (get_bits1(gb)) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
192 skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround |
7501 | 193 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
194 decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
195 decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE, gb, num_side ); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
196 decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK, gb, num_back ); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
197 decode_channel_map(NULL, new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE, gb, num_lfe ); |
7501 | 198 |
199 skip_bits_long(gb, 4 * num_assoc_data); | |
200 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
201 decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC, gb, num_cc ); |
7501 | 202 |
203 align_get_bits(gb); | |
204 | |
205 /* comment field, first byte is length */ | |
206 skip_bits_long(gb, 8 * get_bits(gb, 8)); | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
207 return 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
208 } |
7501 | 209 |
7539 | 210 /** |
211 * Set up channel positions based on a default channel configuration | |
212 * as specified in table 1.17. | |
213 * | |
214 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
215 * | |
216 * @return Returns error status. 0 - OK, !0 - error | |
217 */ | |
218 static int set_default_channel_config(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], | |
219 int channel_config) | |
220 { | |
221 if(channel_config < 1 || channel_config > 7) { | |
222 av_log(ac->avccontext, AV_LOG_ERROR, "invalid default channel configuration (%d)\n", | |
223 channel_config); | |
224 return -1; | |
225 } | |
226 | |
227 /* default channel configurations: | |
228 * | |
229 * 1ch : front center (mono) | |
230 * 2ch : L + R (stereo) | |
231 * 3ch : front center + L + R | |
232 * 4ch : front center + L + R + back center | |
233 * 5ch : front center + L + R + back stereo | |
234 * 6ch : front center + L + R + back stereo + LFE | |
235 * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE | |
236 */ | |
237 | |
238 if(channel_config != 2) | |
239 new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono) | |
240 if(channel_config > 1) | |
241 new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo) | |
242 if(channel_config == 4) | |
243 new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK; // back center | |
244 if(channel_config > 4) | |
245 new_che_pos[TYPE_CPE][(channel_config == 7) + 1] | |
246 = AAC_CHANNEL_BACK; // back stereo | |
247 if(channel_config > 5) | |
248 new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE; // LFE | |
249 if(channel_config == 7) | |
250 new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right | |
251 | |
252 return 0; | |
253 } | |
254 | |
7578 | 255 /** |
256 * Decode GA "General Audio" specific configuration; reference: table 4.1. | |
257 * | |
258 * @return Returns error status. 0 - OK, !0 - error | |
259 */ | |
260 static int decode_ga_specific_config(AACContext * ac, GetBitContext * gb, int channel_config) { | |
261 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; | |
262 int extension_flag, ret; | |
263 | |
264 if(get_bits1(gb)) { // frameLengthFlag | |
265 av_log_missing_feature(ac->avccontext, "960/120 MDCT window is", 1); | |
7539 | 266 return -1; |
267 } | |
268 | |
269 if (get_bits1(gb)) // dependsOnCoreCoder | |
270 skip_bits(gb, 14); // coreCoderDelay | |
271 extension_flag = get_bits1(gb); | |
272 | |
273 if(ac->m4ac.object_type == AOT_AAC_SCALABLE || | |
274 ac->m4ac.object_type == AOT_ER_AAC_SCALABLE) | |
275 skip_bits(gb, 3); // layerNr | |
276 | |
277 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
278 if (channel_config == 0) { | |
279 skip_bits(gb, 4); // element_instance_tag | |
280 if((ret = decode_pce(ac, new_che_pos, gb))) | |
281 return ret; | |
282 } else { | |
283 if((ret = set_default_channel_config(ac, new_che_pos, channel_config))) | |
284 return ret; | |
285 } | |
286 if((ret = output_configure(ac, ac->che_pos, new_che_pos))) | |
287 return ret; | |
288 | |
289 if (extension_flag) { | |
290 switch (ac->m4ac.object_type) { | |
291 case AOT_ER_BSAC: | |
292 skip_bits(gb, 5); // numOfSubFrame | |
293 skip_bits(gb, 11); // layer_length | |
294 break; | |
295 case AOT_ER_AAC_LC: | |
296 case AOT_ER_AAC_LTP: | |
297 case AOT_ER_AAC_SCALABLE: | |
298 case AOT_ER_AAC_LD: | |
299 skip_bits(gb, 3); /* aacSectionDataResilienceFlag | |
300 * aacScalefactorDataResilienceFlag | |
301 * aacSpectralDataResilienceFlag | |
302 */ | |
303 break; | |
304 } | |
305 skip_bits1(gb); // extensionFlag3 (TBD in version 3) | |
306 } | |
307 return 0; | |
308 } | |
309 | |
310 /** | |
311 * Decode audio specific configuration; reference: table 1.13. | |
312 * | |
313 * @param data pointer to AVCodecContext extradata | |
314 * @param data_size size of AVCCodecContext extradata | |
315 * | |
316 * @return Returns error status. 0 - OK, !0 - error | |
317 */ | |
318 static int decode_audio_specific_config(AACContext * ac, void *data, int data_size) { | |
319 GetBitContext gb; | |
320 int i; | |
321 | |
322 init_get_bits(&gb, data, data_size * 8); | |
323 | |
324 if((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0) | |
325 return -1; | |
326 if(ac->m4ac.sampling_index > 11) { | |
327 av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); | |
328 return -1; | |
329 } | |
330 | |
331 skip_bits_long(&gb, i); | |
332 | |
333 switch (ac->m4ac.object_type) { | |
334 case AOT_AAC_LC: | |
335 if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config)) | |
336 return -1; | |
337 break; | |
338 default: | |
339 av_log(ac->avccontext, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n", | |
340 ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type); | |
341 return -1; | |
342 } | |
343 return 0; | |
344 } | |
345 | |
7578 | 346 /** |
347 * linear congruential pseudorandom number generator | |
348 * | |
349 * @param previous_val pointer to the current state of the generator | |
350 * | |
351 * @return Returns a 32-bit pseudorandom integer | |
352 */ | |
353 static av_always_inline int lcg_random(int previous_val) { | |
354 return previous_val * 1664525 + 1013904223; | |
355 } | |
356 | |
7501 | 357 static av_cold int aac_decode_init(AVCodecContext * avccontext) { |
358 AACContext * ac = avccontext->priv_data; | |
359 int i; | |
360 | |
361 ac->avccontext = avccontext; | |
362 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
363 if (avccontext->extradata_size <= 0 || |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
364 decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size)) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
365 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
366 |
7539 | 367 avccontext->sample_fmt = SAMPLE_FMT_S16; |
7501 | 368 avccontext->sample_rate = ac->m4ac.sample_rate; |
369 avccontext->frame_size = 1024; | |
370 | |
371 AAC_INIT_VLC_STATIC( 0, 144); | |
372 AAC_INIT_VLC_STATIC( 1, 114); | |
373 AAC_INIT_VLC_STATIC( 2, 188); | |
374 AAC_INIT_VLC_STATIC( 3, 180); | |
375 AAC_INIT_VLC_STATIC( 4, 172); | |
376 AAC_INIT_VLC_STATIC( 5, 140); | |
377 AAC_INIT_VLC_STATIC( 6, 168); | |
378 AAC_INIT_VLC_STATIC( 7, 114); | |
379 AAC_INIT_VLC_STATIC( 8, 262); | |
380 AAC_INIT_VLC_STATIC( 9, 248); | |
381 AAC_INIT_VLC_STATIC(10, 384); | |
382 | |
383 dsputil_init(&ac->dsp, avccontext); | |
384 | |
7539 | 385 ac->random_state = 0x1f2e3d4c; |
386 | |
7501 | 387 // -1024 - Compensate wrong IMDCT method. |
388 // 32768 - Required to scale values to the correct range for the bias method | |
389 // for float to int16 conversion. | |
390 | |
391 if(ac->dsp.float_to_int16 == ff_float_to_int16_c) { | |
392 ac->add_bias = 385.0f; | |
393 ac->sf_scale = 1. / (-1024. * 32768.); | |
394 ac->sf_offset = 0; | |
395 } else { | |
396 ac->add_bias = 0.0f; | |
397 ac->sf_scale = 1. / -1024.; | |
398 ac->sf_offset = 60; | |
399 } | |
400 | |
401 #ifndef CONFIG_HARDCODED_TABLES | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
402 for (i = 0; i < 316; i++) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
403 ff_aac_pow2sf_tab[i] = pow(2, (i - 200)/4.); |
7501 | 404 #endif /* CONFIG_HARDCODED_TABLES */ |
405 | |
406 INIT_VLC_STATIC(&vlc_scalefactors, 7, sizeof(ff_aac_scalefactor_code)/sizeof(ff_aac_scalefactor_code[0]), | |
407 ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]), | |
408 ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]), | |
409 352); | |
410 | |
411 ff_mdct_init(&ac->mdct, 11, 1); | |
412 ff_mdct_init(&ac->mdct_small, 8, 1); | |
7581 | 413 // window initialization |
414 ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024); | |
415 ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128); | |
416 ff_sine_window_init(ff_sine_1024, 1024); | |
417 ff_sine_window_init(ff_sine_128, 128); | |
418 | |
7501 | 419 return 0; |
420 } | |
421 | |
7539 | 422 /** |
423 * Skip data_stream_element; reference: table 4.10. | |
424 */ | |
425 static void skip_data_stream_element(GetBitContext * gb) { | |
7501 | 426 int byte_align = get_bits1(gb); |
427 int count = get_bits(gb, 8); | |
428 if (count == 255) | |
429 count += get_bits(gb, 8); | |
430 if (byte_align) | |
431 align_get_bits(gb); | |
432 skip_bits_long(gb, 8 * count); | |
433 } | |
434 | |
435 /** | |
7539 | 436 * Decode Individual Channel Stream info; reference: table 4.6. |
437 * | |
438 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
439 */ | |
440 static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb, int common_window) { | |
441 if (get_bits1(gb)) { | |
442 av_log(ac->avccontext, AV_LOG_ERROR, "Reserved bit set.\n"); | |
443 memset(ics, 0, sizeof(IndividualChannelStream)); | |
444 return -1; | |
445 } | |
446 ics->window_sequence[1] = ics->window_sequence[0]; | |
447 ics->window_sequence[0] = get_bits(gb, 2); | |
448 ics->use_kb_window[1] = ics->use_kb_window[0]; | |
449 ics->use_kb_window[0] = get_bits1(gb); | |
450 ics->num_window_groups = 1; | |
451 ics->group_len[0] = 1; | |
7581 | 452 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
453 int i; | |
454 ics->max_sfb = get_bits(gb, 4); | |
455 for (i = 0; i < 7; i++) { | |
456 if (get_bits1(gb)) { | |
457 ics->group_len[ics->num_window_groups-1]++; | |
458 } else { | |
459 ics->num_window_groups++; | |
460 ics->group_len[ics->num_window_groups-1] = 1; | |
461 } | |
462 } | |
463 ics->num_windows = 8; | |
464 ics->swb_offset = swb_offset_128[ac->m4ac.sampling_index]; | |
465 ics->num_swb = ff_aac_num_swb_128[ac->m4ac.sampling_index]; | |
466 ics->tns_max_bands = tns_max_bands_128[ac->m4ac.sampling_index]; | |
467 } else { | |
468 ics->max_sfb = get_bits(gb, 6); | |
469 ics->num_windows = 1; | |
470 ics->swb_offset = swb_offset_1024[ac->m4ac.sampling_index]; | |
471 ics->num_swb = ff_aac_num_swb_1024[ac->m4ac.sampling_index]; | |
472 ics->tns_max_bands = tns_max_bands_1024[ac->m4ac.sampling_index]; | |
7578 | 473 if (get_bits1(gb)) { |
474 av_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1); | |
475 memset(ics, 0, sizeof(IndividualChannelStream)); | |
476 return -1; | |
477 } | |
478 } | |
479 | |
480 if(ics->max_sfb > ics->num_swb) { | |
481 av_log(ac->avccontext, AV_LOG_ERROR, | |
482 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n", | |
483 ics->max_sfb, ics->num_swb); | |
484 memset(ics, 0, sizeof(IndividualChannelStream)); | |
485 return -1; | |
486 } | |
487 | |
7539 | 488 return 0; |
489 } | |
490 | |
491 /** | |
492 * Decode band types (section_data payload); reference: table 4.46. | |
493 * | |
494 * @param band_type array of the used band type | |
495 * @param band_type_run_end array of the last scalefactor band of a band type run | |
496 * | |
497 * @return Returns error status. 0 - OK, !0 - error | |
498 */ | |
499 static int decode_band_types(AACContext * ac, enum BandType band_type[120], | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
500 int band_type_run_end[120], GetBitContext * gb, IndividualChannelStream * ics) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
501 int g, idx = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
502 const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
503 for (g = 0; g < ics->num_window_groups; g++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
504 int k = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
505 while (k < ics->max_sfb) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
506 uint8_t sect_len = k; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
507 int sect_len_incr; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
508 int sect_band_type = get_bits(gb, 4); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
509 if (sect_band_type == 12) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
510 av_log(ac->avccontext, AV_LOG_ERROR, "invalid band type\n"); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
511 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
512 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
513 while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits)-1) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
514 sect_len += sect_len_incr; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
515 sect_len += sect_len_incr; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
516 if (sect_len > ics->max_sfb) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
517 av_log(ac->avccontext, AV_LOG_ERROR, |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
518 "Number of bands (%d) exceeds limit (%d).\n", |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
519 sect_len, ics->max_sfb); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
520 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
521 } |
7581 | 522 for (; k < sect_len; k++) { |
523 band_type [idx] = sect_band_type; | |
524 band_type_run_end[idx++] = sect_len; | |
525 } | |
7539 | 526 } |
527 } | |
528 return 0; | |
529 } | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
530 |
7539 | 531 /** |
532 * Decode scalefactors; reference: table 4.47. | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
533 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
534 * @param global_gain first scalefactor value as scalefactors are differentially coded |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
535 * @param band_type array of the used band type |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
536 * @param band_type_run_end array of the last scalefactor band of a band type run |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
537 * @param sf array of scalefactors or intensity stereo positions |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
538 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
539 * @return Returns error status. 0 - OK, !0 - error |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
540 */ |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
541 static int decode_scalefactors(AACContext * ac, float sf[120], GetBitContext * gb, |
7540 | 542 unsigned int global_gain, IndividualChannelStream * ics, |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
543 enum BandType band_type[120], int band_type_run_end[120]) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
544 const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
545 int g, i, idx = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
546 int offset[3] = { global_gain, global_gain - 90, 100 }; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
547 int noise_flag = 1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
548 static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" }; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
549 for (g = 0; g < ics->num_window_groups; g++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
550 for (i = 0; i < ics->max_sfb;) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
551 int run_end = band_type_run_end[idx]; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
552 if (band_type[idx] == ZERO_BT) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
553 for(; i < run_end; i++, idx++) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
554 sf[idx] = 0.; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
555 }else if((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
556 for(; i < run_end; i++, idx++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
557 offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
558 if(offset[2] > 255U) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
559 av_log(ac->avccontext, AV_LOG_ERROR, |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
560 "%s (%d) out of range.\n", sf_str[2], offset[2]); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
561 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
562 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
563 sf[idx] = ff_aac_pow2sf_tab[-offset[2] + 300]; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
564 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
565 }else if(band_type[idx] == NOISE_BT) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
566 for(; i < run_end; i++, idx++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
567 if(noise_flag-- > 0) |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
568 offset[1] += get_bits(gb, 9) - 256; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
569 else |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
570 offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
571 if(offset[1] > 255U) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
572 av_log(ac->avccontext, AV_LOG_ERROR, |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
573 "%s (%d) out of range.\n", sf_str[1], offset[1]); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
574 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
575 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
576 sf[idx] = -ff_aac_pow2sf_tab[ offset[1] + sf_offset]; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
577 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
578 }else { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
579 for(; i < run_end; i++, idx++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
580 offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
581 if(offset[0] > 255U) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
582 av_log(ac->avccontext, AV_LOG_ERROR, |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
583 "%s (%d) out of range.\n", sf_str[0], offset[0]); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
584 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
585 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
586 sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset]; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
587 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
588 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
589 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
590 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
591 return 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
592 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
593 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
594 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
595 * Decode pulse data; reference: table 4.7. |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
596 */ |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
597 static int decode_pulses(Pulse * pulse, GetBitContext * gb, const uint16_t * swb_offset, int num_swb) { |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
598 int i, pulse_swb; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
599 pulse->num_pulse = get_bits(gb, 2) + 1; |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
600 pulse_swb = get_bits(gb, 6); |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
601 if (pulse_swb >= num_swb) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
602 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
603 pulse->pos[0] = swb_offset[pulse_swb]; |
7856
0882c93a0c11
Operands of '+' are not necessarily evaluated in order so r15311 was pointless.
superdump
parents:
7855
diff
changeset
|
604 pulse->pos[0] += get_bits(gb, 5); |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
605 if (pulse->pos[0] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
606 return -1; |
7580 | 607 pulse->amp[0] = get_bits(gb, 4); |
608 for (i = 1; i < pulse->num_pulse; i++) { | |
609 pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i-1]; | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
610 if (pulse->pos[i] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
611 return -1; |
7580 | 612 pulse->amp[i] = get_bits(gb, 4); |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
613 } |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
614 return 0; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
615 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
616 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
617 /** |
7609 | 618 * Decode Temporal Noise Shaping data; reference: table 4.48. |
619 * | |
620 * @return Returns error status. 0 - OK, !0 - error | |
621 */ | |
622 static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns, | |
623 GetBitContext * gb, const IndividualChannelStream * ics) { | |
624 int w, filt, i, coef_len, coef_res, coef_compress; | |
625 const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE; | |
626 const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12; | |
627 for (w = 0; w < ics->num_windows; w++) { | |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
628 if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) { |
7609 | 629 coef_res = get_bits1(gb); |
630 | |
7638 | 631 for (filt = 0; filt < tns->n_filt[w]; filt++) { |
632 int tmp2_idx; | |
633 tns->length[w][filt] = get_bits(gb, 6 - 2*is8); | |
7609 | 634 |
7638 | 635 if ((tns->order[w][filt] = get_bits(gb, 5 - 2*is8)) > tns_max_order) { |
636 av_log(ac->avccontext, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.", | |
637 tns->order[w][filt], tns_max_order); | |
638 tns->order[w][filt] = 0; | |
639 return -1; | |
640 } | |
7850
77030651ddd0
Only read some of TNS bitstream data in the case that the TNS filter order is
superdump
parents:
7845
diff
changeset
|
641 if (tns->order[w][filt]) { |
7851 | 642 tns->direction[w][filt] = get_bits1(gb); |
643 coef_compress = get_bits1(gb); | |
644 coef_len = coef_res + 3 - coef_compress; | |
645 tmp2_idx = 2*coef_compress + coef_res; | |
7638 | 646 |
7851 | 647 for (i = 0; i < tns->order[w][filt]; i++) |
648 tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)]; | |
7850
77030651ddd0
Only read some of TNS bitstream data in the case that the TNS filter order is
superdump
parents:
7845
diff
changeset
|
649 } |
7609 | 650 } |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
651 } |
7609 | 652 } |
653 return 0; | |
654 } | |
655 | |
656 /** | |
7539 | 657 * Decode Mid/Side data; reference: table 4.54. |
658 * | |
659 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
660 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
661 * [3] reserved for scalable AAC | |
662 */ | |
663 static void decode_mid_side_stereo(ChannelElement * cpe, GetBitContext * gb, | |
664 int ms_present) { | |
7578 | 665 int idx; |
666 if (ms_present == 1) { | |
667 for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++) | |
668 cpe->ms_mask[idx] = get_bits1(gb); | |
669 } else if (ms_present == 2) { | |
670 memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0])); | |
671 } | |
672 } | |
7539 | 673 |
674 /** | |
7581 | 675 * Decode spectral data; reference: table 4.50. |
676 * Dequantize and scale spectral data; reference: 4.6.3.3. | |
677 * | |
678 * @param coef array of dequantized, scaled spectral data | |
679 * @param sf array of scalefactors or intensity stereo positions | |
680 * @param pulse_present set if pulses are present | |
681 * @param pulse pointer to pulse data struct | |
682 * @param band_type array of the used band type | |
683 * | |
684 * @return Returns error status. 0 - OK, !0 - error | |
685 */ | |
686 static int decode_spectrum_and_dequant(AACContext * ac, float coef[1024], GetBitContext * gb, float sf[120], | |
687 int pulse_present, const Pulse * pulse, const IndividualChannelStream * ics, enum BandType band_type[120]) { | |
688 int i, k, g, idx = 0; | |
689 const int c = 1024/ics->num_windows; | |
690 const uint16_t * offsets = ics->swb_offset; | |
691 float *coef_base = coef; | |
692 | |
693 for (g = 0; g < ics->num_windows; g++) | |
694 memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float)*(c - offsets[ics->max_sfb])); | |
695 | |
696 for (g = 0; g < ics->num_window_groups; g++) { | |
697 for (i = 0; i < ics->max_sfb; i++, idx++) { | |
698 const int cur_band_type = band_type[idx]; | |
699 const int dim = cur_band_type >= FIRST_PAIR_BT ? 2 : 4; | |
700 const int is_cb_unsigned = IS_CODEBOOK_UNSIGNED(cur_band_type); | |
701 int group; | |
702 if (cur_band_type == ZERO_BT) { | |
703 for (group = 0; group < ics->group_len[g]; group++) { | |
704 memset(coef + group * 128 + offsets[i], 0, (offsets[i+1] - offsets[i])*sizeof(float)); | |
705 } | |
706 }else if (cur_band_type == NOISE_BT) { | |
707 const float scale = sf[idx] / ((offsets[i+1] - offsets[i]) * PNS_MEAN_ENERGY); | |
708 for (group = 0; group < ics->group_len[g]; group++) { | |
709 for (k = offsets[i]; k < offsets[i+1]; k++) { | |
710 ac->random_state = lcg_random(ac->random_state); | |
711 coef[group*128+k] = ac->random_state * scale; | |
712 } | |
713 } | |
714 }else if (cur_band_type != INTENSITY_BT2 && cur_band_type != INTENSITY_BT) { | |
715 for (group = 0; group < ics->group_len[g]; group++) { | |
716 for (k = offsets[i]; k < offsets[i+1]; k += dim) { | |
717 const int index = get_vlc2(gb, vlc_spectral[cur_band_type - 1].table, 6, 3); | |
718 const int coef_tmp_idx = (group << 7) + k; | |
719 const float *vq_ptr; | |
720 int j; | |
721 if(index >= ff_aac_spectral_sizes[cur_band_type - 1]) { | |
722 av_log(ac->avccontext, AV_LOG_ERROR, | |
723 "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n", | |
724 cur_band_type - 1, index, ff_aac_spectral_sizes[cur_band_type - 1]); | |
725 return -1; | |
726 } | |
727 vq_ptr = &ff_aac_codebook_vectors[cur_band_type - 1][index * dim]; | |
728 if (is_cb_unsigned) { | |
729 for (j = 0; j < dim; j++) | |
730 if (vq_ptr[j]) | |
731 coef[coef_tmp_idx + j] = 1 - 2*(int)get_bits1(gb); | |
732 }else { | |
733 for (j = 0; j < dim; j++) | |
734 coef[coef_tmp_idx + j] = 1.0f; | |
735 } | |
736 if (cur_band_type == ESC_BT) { | |
737 for (j = 0; j < 2; j++) { | |
738 if (vq_ptr[j] == 64.0f) { | |
739 int n = 4; | |
740 /* The total length of escape_sequence must be < 22 bits according | |
741 to the specification (i.e. max is 11111111110xxxxxxxxxx). */ | |
742 while (get_bits1(gb) && n < 15) n++; | |
743 if(n == 15) { | |
744 av_log(ac->avccontext, AV_LOG_ERROR, "error in spectral data, ESC overflow\n"); | |
745 return -1; | |
746 } | |
747 n = (1<<n) + get_bits(gb, n); | |
748 coef[coef_tmp_idx + j] *= cbrtf(fabsf(n)) * n; | |
749 }else | |
750 coef[coef_tmp_idx + j] *= vq_ptr[j]; | |
751 } | |
752 }else | |
753 for (j = 0; j < dim; j++) | |
754 coef[coef_tmp_idx + j] *= vq_ptr[j]; | |
755 for (j = 0; j < dim; j++) | |
756 coef[coef_tmp_idx + j] *= sf[idx]; | |
757 } | |
758 } | |
759 } | |
760 } | |
761 coef += ics->group_len[g]<<7; | |
762 } | |
763 | |
764 if (pulse_present) { | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
765 idx = 0; |
7581 | 766 for(i = 0; i < pulse->num_pulse; i++){ |
767 float co = coef_base[ pulse->pos[i] ]; | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
768 while(offsets[idx + 1] <= pulse->pos[i]) |
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
769 idx++; |
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
770 if (band_type[idx] != NOISE_BT && sf[idx]) { |
7858 | 771 float ico = -pulse->amp[i]; |
772 if (co) { | |
773 co /= sf[idx]; | |
774 ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico); | |
775 } | |
776 coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx]; | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
777 } |
7581 | 778 } |
779 } | |
780 return 0; | |
781 } | |
782 | |
783 /** | |
7539 | 784 * Decode an individual_channel_stream payload; reference: table 4.44. |
785 * | |
786 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
787 * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.) | |
788 * | |
789 * @return Returns error status. 0 - OK, !0 - error | |
790 */ | |
791 static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext * gb, int common_window, int scale_flag) { | |
792 Pulse pulse; | |
793 TemporalNoiseShaping * tns = &sce->tns; | |
794 IndividualChannelStream * ics = &sce->ics; | |
795 float * out = sce->coeffs; | |
796 int global_gain, pulse_present = 0; | |
797 | |
7580 | 798 /* This assignment is to silence a GCC warning about the variable being used |
799 * uninitialized when in fact it always is. | |
7539 | 800 */ |
801 pulse.num_pulse = 0; | |
802 | |
803 global_gain = get_bits(gb, 8); | |
804 | |
805 if (!common_window && !scale_flag) { | |
806 if (decode_ics_info(ac, ics, gb, 0) < 0) | |
807 return -1; | |
808 } | |
809 | |
810 if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0) | |
811 return -1; | |
812 if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0) | |
813 return -1; | |
814 | |
815 pulse_present = 0; | |
816 if (!scale_flag) { | |
817 if ((pulse_present = get_bits1(gb))) { | |
818 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { | |
819 av_log(ac->avccontext, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n"); | |
820 return -1; | |
821 } | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
822 if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) { |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
823 av_log(ac->avccontext, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n"); |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
824 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
825 } |
7539 | 826 } |
827 if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics)) | |
828 return -1; | |
829 if (get_bits1(gb)) { | |
830 av_log_missing_feature(ac->avccontext, "SSR", 1); | |
831 return -1; | |
832 } | |
833 } | |
834 | |
7580 | 835 if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0) |
7539 | 836 return -1; |
837 return 0; | |
838 } | |
839 | |
840 /** | |
7581 | 841 * Mid/Side stereo decoding; reference: 4.6.8.1.3. |
842 */ | |
843 static void apply_mid_side_stereo(ChannelElement * cpe) { | |
844 const IndividualChannelStream * ics = &cpe->ch[0].ics; | |
845 float *ch0 = cpe->ch[0].coeffs; | |
846 float *ch1 = cpe->ch[1].coeffs; | |
847 int g, i, k, group, idx = 0; | |
848 const uint16_t * offsets = ics->swb_offset; | |
849 for (g = 0; g < ics->num_window_groups; g++) { | |
850 for (i = 0; i < ics->max_sfb; i++, idx++) { | |
851 if (cpe->ms_mask[idx] && | |
852 cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) { | |
853 for (group = 0; group < ics->group_len[g]; group++) { | |
854 for (k = offsets[i]; k < offsets[i+1]; k++) { | |
855 float tmp = ch0[group*128 + k] - ch1[group*128 + k]; | |
856 ch0[group*128 + k] += ch1[group*128 + k]; | |
857 ch1[group*128 + k] = tmp; | |
858 } | |
859 } | |
860 } | |
861 } | |
862 ch0 += ics->group_len[g]*128; | |
863 ch1 += ics->group_len[g]*128; | |
864 } | |
865 } | |
866 | |
867 /** | |
868 * intensity stereo decoding; reference: 4.6.8.2.3 | |
869 * | |
870 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
871 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
872 * [3] reserved for scalable AAC | |
873 */ | |
874 static void apply_intensity_stereo(ChannelElement * cpe, int ms_present) { | |
875 const IndividualChannelStream * ics = &cpe->ch[1].ics; | |
876 SingleChannelElement * sce1 = &cpe->ch[1]; | |
877 float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs; | |
878 const uint16_t * offsets = ics->swb_offset; | |
879 int g, group, i, k, idx = 0; | |
880 int c; | |
881 float scale; | |
882 for (g = 0; g < ics->num_window_groups; g++) { | |
883 for (i = 0; i < ics->max_sfb;) { | |
884 if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) { | |
885 const int bt_run_end = sce1->band_type_run_end[idx]; | |
886 for (; i < bt_run_end; i++, idx++) { | |
887 c = -1 + 2 * (sce1->band_type[idx] - 14); | |
888 if (ms_present) | |
889 c *= 1 - 2 * cpe->ms_mask[idx]; | |
890 scale = c * sce1->sf[idx]; | |
891 for (group = 0; group < ics->group_len[g]; group++) | |
892 for (k = offsets[i]; k < offsets[i+1]; k++) | |
893 coef1[group*128 + k] = scale * coef0[group*128 + k]; | |
894 } | |
895 } else { | |
896 int bt_run_end = sce1->band_type_run_end[idx]; | |
897 idx += bt_run_end - i; | |
898 i = bt_run_end; | |
899 } | |
900 } | |
901 coef0 += ics->group_len[g]*128; | |
902 coef1 += ics->group_len[g]*128; | |
903 } | |
904 } | |
905 | |
906 /** | |
7539 | 907 * Decode a channel_pair_element; reference: table 4.4. |
908 * | |
909 * @param elem_id Identifies the instance of a syntax element. | |
910 * | |
911 * @return Returns error status. 0 - OK, !0 - error | |
912 */ | |
913 static int decode_cpe(AACContext * ac, GetBitContext * gb, int elem_id) { | |
914 int i, ret, common_window, ms_present = 0; | |
915 ChannelElement * cpe; | |
916 | |
917 cpe = ac->che[TYPE_CPE][elem_id]; | |
918 common_window = get_bits1(gb); | |
919 if (common_window) { | |
920 if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1)) | |
921 return -1; | |
922 i = cpe->ch[1].ics.use_kb_window[0]; | |
923 cpe->ch[1].ics = cpe->ch[0].ics; | |
924 cpe->ch[1].ics.use_kb_window[1] = i; | |
925 ms_present = get_bits(gb, 2); | |
926 if(ms_present == 3) { | |
927 av_log(ac->avccontext, AV_LOG_ERROR, "ms_present = 3 is reserved.\n"); | |
928 return -1; | |
929 } else if(ms_present) | |
930 decode_mid_side_stereo(cpe, gb, ms_present); | |
931 } | |
932 if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0))) | |
933 return ret; | |
934 if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0))) | |
935 return ret; | |
936 | |
937 if (common_window && ms_present) | |
938 apply_mid_side_stereo(cpe); | |
939 | |
7580 | 940 apply_intensity_stereo(cpe, ms_present); |
7539 | 941 return 0; |
942 } | |
943 | |
7581 | 944 /** |
945 * Decode coupling_channel_element; reference: table 4.8. | |
946 * | |
947 * @param elem_id Identifies the instance of a syntax element. | |
948 * | |
949 * @return Returns error status. 0 - OK, !0 - error | |
950 */ | |
951 static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) { | |
952 int num_gain = 0; | |
7891
13ee9bb85721
Zero 'idx' for each iteration of the coupling gain loop and as it is only used
superdump
parents:
7890
diff
changeset
|
953 int c, g, sfb, ret; |
7581 | 954 int sign; |
955 float scale; | |
956 SingleChannelElement * sce = &che->ch[0]; | |
957 ChannelCoupling * coup = &che->coup; | |
958 | |
7578 | 959 coup->coupling_point = 2*get_bits1(gb); |
960 coup->num_coupled = get_bits(gb, 3); | |
961 for (c = 0; c <= coup->num_coupled; c++) { | |
962 num_gain++; | |
963 coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE; | |
964 coup->id_select[c] = get_bits(gb, 4); | |
965 if (coup->type[c] == TYPE_CPE) { | |
966 coup->ch_select[c] = get_bits(gb, 2); | |
967 if (coup->ch_select[c] == 3) | |
968 num_gain++; | |
969 } else | |
970 coup->ch_select[c] = 1; | |
971 } | |
972 coup->coupling_point += get_bits1(gb); | |
973 | |
974 if (coup->coupling_point == 2) { | |
975 av_log(ac->avccontext, AV_LOG_ERROR, | |
976 "Independently switched CCE with 'invalid' domain signalled.\n"); | |
977 memset(coup, 0, sizeof(ChannelCoupling)); | |
978 return -1; | |
979 } | |
980 | |
981 sign = get_bits(gb, 1); | |
7889
fdd3e68dcf94
Cast the return value of get_bits() to signed integer such that the subtraction
superdump
parents:
7871
diff
changeset
|
982 scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3)); |
7578 | 983 |
984 if ((ret = decode_ics(ac, sce, gb, 0, 0))) | |
985 return ret; | |
986 | |
987 for (c = 0; c < num_gain; c++) { | |
7891
13ee9bb85721
Zero 'idx' for each iteration of the coupling gain loop and as it is only used
superdump
parents:
7890
diff
changeset
|
988 int idx = 0; |
7578 | 989 int cge = 1; |
990 int gain = 0; | |
991 float gain_cache = 1.; | |
992 if (c) { | |
993 cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb); | |
994 gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0; | |
995 gain_cache = pow(scale, gain); | |
996 } | |
7890 | 997 for (g = 0; g < sce->ics.num_window_groups; g++) { |
998 for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) { | |
7578 | 999 if (sce->band_type[idx] != ZERO_BT) { |
1000 if (!cge) { | |
1001 int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; | |
1002 if (t) { | |
1003 int s = 1; | |
1004 if (sign) { | |
1005 s -= 2 * (t & 0x1); | |
1006 t >>= 1; | |
1007 } | |
1008 gain += t; | |
1009 gain_cache = pow(scale, gain) * s; | |
1010 } | |
1011 } | |
1012 coup->gain[c][idx] = gain_cache; | |
1013 } | |
7890 | 1014 } |
1015 } | |
7578 | 1016 } |
1017 return 0; | |
1018 } | |
1019 | |
7539 | 1020 /** |
1021 * Decode Spectral Band Replication extension data; reference: table 4.55. | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1022 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1023 * @param crc flag indicating the presence of CRC checksum |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1024 * @param cnt length of TYPE_FIL syntactic element in bytes |
7539 | 1025 * |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1026 * @return Returns number of bytes consumed from the TYPE_FIL element. |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1027 */ |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1028 static int decode_sbr_extension(AACContext * ac, GetBitContext * gb, int crc, int cnt) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1029 // TODO : sbr_extension implementation |
7540 | 1030 av_log_missing_feature(ac->avccontext, "SBR", 0); |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1031 skip_bits_long(gb, 8*cnt - 4); // -4 due to reading extension type |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1032 return cnt; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1033 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1034 |
7539 | 1035 /** |
7578 | 1036 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53. |
1037 * | |
1038 * @return Returns number of bytes consumed. | |
1039 */ | |
1040 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, GetBitContext * gb) { | |
1041 int i; | |
1042 int num_excl_chan = 0; | |
1043 | |
1044 do { | |
1045 for (i = 0; i < 7; i++) | |
1046 che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb); | |
1047 } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb)); | |
1048 | |
1049 return num_excl_chan / 7; | |
1050 } | |
1051 | |
1052 /** | |
7539 | 1053 * Decode dynamic range information; reference: table 4.52. |
1054 * | |
1055 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1056 * | |
1057 * @return Returns number of bytes consumed. | |
1058 */ | |
1059 static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext * gb, int cnt) { | |
1060 int n = 1; | |
1061 int drc_num_bands = 1; | |
1062 int i; | |
1063 | |
1064 /* pce_tag_present? */ | |
1065 if(get_bits1(gb)) { | |
1066 che_drc->pce_instance_tag = get_bits(gb, 4); | |
1067 skip_bits(gb, 4); // tag_reserved_bits | |
1068 n++; | |
1069 } | |
1070 | |
1071 /* excluded_chns_present? */ | |
1072 if(get_bits1(gb)) { | |
1073 n += decode_drc_channel_exclusions(che_drc, gb); | |
1074 } | |
1075 | |
1076 /* drc_bands_present? */ | |
1077 if (get_bits1(gb)) { | |
1078 che_drc->band_incr = get_bits(gb, 4); | |
1079 che_drc->interpolation_scheme = get_bits(gb, 4); | |
1080 n++; | |
1081 drc_num_bands += che_drc->band_incr; | |
1082 for (i = 0; i < drc_num_bands; i++) { | |
1083 che_drc->band_top[i] = get_bits(gb, 8); | |
1084 n++; | |
1085 } | |
1086 } | |
1087 | |
1088 /* prog_ref_level_present? */ | |
1089 if (get_bits1(gb)) { | |
1090 che_drc->prog_ref_level = get_bits(gb, 7); | |
1091 skip_bits1(gb); // prog_ref_level_reserved_bits | |
1092 n++; | |
1093 } | |
1094 | |
1095 for (i = 0; i < drc_num_bands; i++) { | |
1096 che_drc->dyn_rng_sgn[i] = get_bits1(gb); | |
1097 che_drc->dyn_rng_ctl[i] = get_bits(gb, 7); | |
1098 n++; | |
1099 } | |
1100 | |
1101 return n; | |
1102 } | |
1103 | |
1104 /** | |
1105 * Decode extension data (incomplete); reference: table 4.51. | |
1106 * | |
1107 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1108 * | |
1109 * @return Returns number of bytes consumed | |
1110 */ | |
1111 static int decode_extension_payload(AACContext * ac, GetBitContext * gb, int cnt) { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1112 int crc_flag = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1113 int res = cnt; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1114 switch (get_bits(gb, 4)) { // extension type |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1115 case EXT_SBR_DATA_CRC: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1116 crc_flag++; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1117 case EXT_SBR_DATA: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1118 res = decode_sbr_extension(ac, gb, crc_flag, cnt); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1119 break; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1120 case EXT_DYNAMIC_RANGE: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1121 res = decode_dynamic_range(&ac->che_drc, gb, cnt); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1122 break; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1123 case EXT_FILL: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1124 case EXT_FILL_DATA: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1125 case EXT_DATA_ELEMENT: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1126 default: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1127 skip_bits_long(gb, 8*cnt - 4); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1128 break; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1129 }; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1130 return res; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1131 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1132 |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1133 /** |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1134 * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3. |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1135 * |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1136 * @param decode 1 if tool is used normally, 0 if tool is used in LTP. |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1137 * @param coef spectral coefficients |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1138 */ |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1139 static void apply_tns(float coef[1024], TemporalNoiseShaping * tns, IndividualChannelStream * ics, int decode) { |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1140 const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb); |
7636 | 1141 int w, filt, m, i; |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1142 int bottom, top, order, start, end, size, inc; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1143 float lpc[TNS_MAX_ORDER]; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1144 |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1145 for (w = 0; w < ics->num_windows; w++) { |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1146 bottom = ics->num_swb; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1147 for (filt = 0; filt < tns->n_filt[w]; filt++) { |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1148 top = bottom; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1149 bottom = FFMAX(0, top - tns->length[w][filt]); |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1150 order = tns->order[w][filt]; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1151 if (order == 0) |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1152 continue; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1153 |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1154 // tns_decode_coef |
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1155 compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0); |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1156 |
7609 | 1157 start = ics->swb_offset[FFMIN(bottom, mmm)]; |
1158 end = ics->swb_offset[FFMIN( top, mmm)]; | |
1159 if ((size = end - start) <= 0) | |
1160 continue; | |
1161 if (tns->direction[w][filt]) { | |
1162 inc = -1; start = end - 1; | |
1163 } else { | |
1164 inc = 1; | |
1165 } | |
1166 start += w * 128; | |
1167 | |
1168 // ar filter | |
1169 for (m = 0; m < size; m++, start += inc) | |
1170 for (i = 1; i <= FFMIN(m, order); i++) | |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1171 coef[start] -= coef[start - i*inc] * lpc[i-1]; |
7609 | 1172 } |
1173 } | |
1174 } | |
1175 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1176 /** |
7539 | 1177 * Conduct IMDCT and windowing. |
1178 */ | |
1179 static void imdct_and_windowing(AACContext * ac, SingleChannelElement * sce) { | |
1180 IndividualChannelStream * ics = &sce->ics; | |
1181 float * in = sce->coeffs; | |
1182 float * out = sce->ret; | |
1183 float * saved = sce->saved; | |
7580 | 1184 const float * swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; |
1185 const float * lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; | |
1186 const float * swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; | |
7539 | 1187 float * buf = ac->buf_mdct; |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1188 DECLARE_ALIGNED(16, float, temp[128]); |
7539 | 1189 int i; |
1190 | |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1191 // imdct |
7578 | 1192 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
1193 if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) | |
1194 av_log(ac->avccontext, AV_LOG_WARNING, | |
1195 "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. " | |
1196 "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n"); | |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1197 for (i = 0; i < 1024; i += 128) |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1198 ff_imdct_half(&ac->mdct_small, buf + i, in + i); |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1199 } else |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1200 ff_imdct_half(&ac->mdct, buf, in); |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1201 |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1202 /* window overlapping |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1203 * NOTE: To simplify the overlapping code, all 'meaningless' short to long |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1204 * and long to short transitions are considered to be short to short |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1205 * transitions. This leaves just two cases (long to long and short to short) |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1206 * with a little special sauce for EIGHT_SHORT_SEQUENCE. |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1207 */ |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1208 if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) && |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1209 (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) { |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1210 ac->dsp.vector_fmul_window( out, saved, buf, lwindow_prev, ac->add_bias, 512); |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1211 } else { |
7662 | 1212 for (i = 0; i < 448; i++) |
1213 out[i] = saved[i] + ac->add_bias; | |
7578 | 1214 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1215 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1216 ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448, buf + 0*128, swindow_prev, ac->add_bias, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1217 ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow, ac->add_bias, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1218 ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow, ac->add_bias, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1219 ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow, ac->add_bias, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1220 ac->dsp.vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, swindow, ac->add_bias, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1221 memcpy( out + 448 + 4*128, temp, 64 * sizeof(float)); |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1222 } else { |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1223 ac->dsp.vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, ac->add_bias, 64); |
7662 | 1224 for (i = 576; i < 1024; i++) |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1225 out[i] = buf[i-512] + ac->add_bias; |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1226 } |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1227 } |
7578 | 1228 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1229 // buffer update |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1230 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1231 for (i = 0; i < 64; i++) |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1232 saved[i] = temp[64 + i] - ac->add_bias; |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1233 ac->dsp.vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, swindow, 0, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1234 ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 0, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1235 ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 0, 64); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1236 memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(float)); |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1237 } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) { |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1238 memcpy( saved, buf + 512, 448 * sizeof(float)); |
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1239 memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(float)); |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1240 } else { // LONG_STOP or ONLY_LONG |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1241 memcpy( saved, buf + 512, 512 * sizeof(float)); |
7578 | 1242 } |
1243 } | |
1244 | |
7539 | 1245 /** |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1246 * Apply dependent channel coupling (applied before IMDCT). |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1247 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1248 * @param index index into coupling gain array |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1249 */ |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1250 static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * sce, ChannelElement * cc, int index) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1251 IndividualChannelStream * ics = &cc->ch[0].ics; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1252 const uint16_t * offsets = ics->swb_offset; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1253 float * dest = sce->coeffs; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1254 const float * src = cc->ch[0].coeffs; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1255 int g, i, group, k, idx = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1256 if(ac->m4ac.object_type == AOT_AAC_LTP) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1257 av_log(ac->avccontext, AV_LOG_ERROR, |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1258 "Dependent coupling is not supported together with LTP\n"); |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1259 return; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1260 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1261 for (g = 0; g < ics->num_window_groups; g++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1262 for (i = 0; i < ics->max_sfb; i++, idx++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1263 if (cc->ch[0].band_type[idx] != ZERO_BT) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1264 for (group = 0; group < ics->group_len[g]; group++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1265 for (k = offsets[i]; k < offsets[i+1]; k++) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1266 // XXX dsputil-ize |
7540 | 1267 dest[group*128+k] += cc->coup.gain[index][idx] * src[group*128+k]; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1268 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1269 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1270 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1271 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1272 dest += ics->group_len[g]*128; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1273 src += ics->group_len[g]*128; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1274 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1275 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1276 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1277 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1278 * Apply independent channel coupling (applied after IMDCT). |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1279 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1280 * @param index index into coupling gain array |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1281 */ |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1282 static void apply_independent_coupling(AACContext * ac, SingleChannelElement * sce, ChannelElement * cc, int index) { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1283 int i; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1284 for (i = 0; i < 1024; i++) |
7540 | 1285 sce->ret[i] += cc->coup.gain[index][0] * (cc->ch[0].ret[i] - ac->add_bias); |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1286 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1287 |
7581 | 1288 /** |
1289 * channel coupling transformation interface | |
1290 * | |
1291 * @param index index into coupling gain array | |
1292 * @param apply_coupling_method pointer to (in)dependent coupling function | |
1293 */ | |
1294 static void apply_channel_coupling(AACContext * ac, ChannelElement * cc, | |
1295 void (*apply_coupling_method)(AACContext * ac, SingleChannelElement * sce, ChannelElement * cc, int index)) | |
1296 { | |
1297 int c; | |
1298 int index = 0; | |
1299 ChannelCoupling * coup = &cc->coup; | |
1300 for (c = 0; c <= coup->num_coupled; c++) { | |
1301 if (ac->che[coup->type[c]][coup->id_select[c]]) { | |
1302 if (coup->ch_select[c] != 2) { | |
1303 apply_coupling_method(ac, &ac->che[coup->type[c]][coup->id_select[c]]->ch[0], cc, index); | |
1304 if (coup->ch_select[c] != 0) | |
1305 index++; | |
1306 } | |
1307 if (coup->ch_select[c] != 1) | |
1308 apply_coupling_method(ac, &ac->che[coup->type[c]][coup->id_select[c]]->ch[1], cc, index++); | |
1309 } else { | |
1310 av_log(ac->avccontext, AV_LOG_ERROR, | |
1311 "coupling target %sE[%d] not available\n", | |
1312 coup->type[c] == TYPE_CPE ? "CP" : "SC", coup->id_select[c]); | |
1313 break; | |
1314 } | |
1315 } | |
1316 } | |
1317 | |
1318 /** | |
1319 * Convert spectral data to float samples, applying all supported tools as appropriate. | |
1320 */ | |
1321 static void spectral_to_sample(AACContext * ac) { | |
1322 int i, type; | |
1323 for (i = 0; i < MAX_ELEM_ID; i++) { | |
1324 for(type = 0; type < 4; type++) { | |
1325 ChannelElement *che = ac->che[type][i]; | |
1326 if(che) { | |
1327 if(che->coup.coupling_point == BEFORE_TNS) | |
1328 apply_channel_coupling(ac, che, apply_dependent_coupling); | |
1329 if(che->ch[0].tns.present) | |
1330 apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1); | |
1331 if(che->ch[1].tns.present) | |
1332 apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1); | |
1333 if(che->coup.coupling_point == BETWEEN_TNS_AND_IMDCT) | |
1334 apply_channel_coupling(ac, che, apply_dependent_coupling); | |
1335 imdct_and_windowing(ac, &che->ch[0]); | |
1336 if(type == TYPE_CPE) | |
1337 imdct_and_windowing(ac, &che->ch[1]); | |
1338 if(che->coup.coupling_point == AFTER_IMDCT) | |
1339 apply_channel_coupling(ac, che, apply_independent_coupling); | |
7578 | 1340 } |
1341 } | |
1342 } | |
1343 } | |
1344 | |
1345 static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data_size, const uint8_t * buf, int buf_size) { | |
1346 AACContext * ac = avccontext->priv_data; | |
1347 GetBitContext gb; | |
1348 enum RawDataBlockType elem_type; | |
1349 int err, elem_id, data_size_tmp; | |
1350 | |
1351 init_get_bits(&gb, buf, buf_size*8); | |
1352 | |
1353 // parse | |
1354 while ((elem_type = get_bits(&gb, 3)) != TYPE_END) { | |
1355 elem_id = get_bits(&gb, 4); | |
1356 err = -1; | |
1357 | |
1358 if(elem_type == TYPE_SCE && elem_id == 1 && | |
1359 !ac->che[TYPE_SCE][elem_id] && ac->che[TYPE_LFE][0]) { | |
1360 /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1] | |
1361 instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have | |
1362 encountered such a stream, transfer the LFE[0] element to SCE[1] */ | |
1363 ac->che[TYPE_SCE][elem_id] = ac->che[TYPE_LFE][0]; | |
1364 ac->che[TYPE_LFE][0] = NULL; | |
1365 } | |
7732
5d93ceaa7a2c
Remove unnecessary portion of a condition. This fixes issue607 and avoids
superdump
parents:
7663
diff
changeset
|
1366 if(elem_type < TYPE_DSE) { |
7578 | 1367 if(!ac->che[elem_type][elem_id]) |
1368 return -1; | |
1369 if(elem_type != TYPE_CCE) | |
1370 ac->che[elem_type][elem_id]->coup.coupling_point = 4; | |
1371 } | |
1372 | |
1373 switch (elem_type) { | |
1374 | |
1375 case TYPE_SCE: | |
1376 err = decode_ics(ac, &ac->che[TYPE_SCE][elem_id]->ch[0], &gb, 0, 0); | |
1377 break; | |
1378 | |
1379 case TYPE_CPE: | |
1380 err = decode_cpe(ac, &gb, elem_id); | |
1381 break; | |
1382 | |
1383 case TYPE_CCE: | |
7733 | 1384 err = decode_cce(ac, &gb, ac->che[TYPE_CCE][elem_id]); |
7578 | 1385 break; |
1386 | |
1387 case TYPE_LFE: | |
1388 err = decode_ics(ac, &ac->che[TYPE_LFE][elem_id]->ch[0], &gb, 0, 0); | |
1389 break; | |
1390 | |
1391 case TYPE_DSE: | |
1392 skip_data_stream_element(&gb); | |
1393 err = 0; | |
1394 break; | |
1395 | |
1396 case TYPE_PCE: | |
1397 { | |
1398 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; | |
1399 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
1400 if((err = decode_pce(ac, new_che_pos, &gb))) | |
1401 break; | |
1402 err = output_configure(ac, ac->che_pos, new_che_pos); | |
1403 break; | |
1404 } | |
1405 | |
1406 case TYPE_FIL: | |
1407 if (elem_id == 15) | |
1408 elem_id += get_bits(&gb, 8) - 1; | |
1409 while (elem_id > 0) | |
1410 elem_id -= decode_extension_payload(ac, &gb, elem_id); | |
1411 err = 0; /* FIXME */ | |
1412 break; | |
1413 | |
1414 default: | |
1415 err = -1; /* should not happen, but keeps compiler happy */ | |
1416 break; | |
1417 } | |
1418 | |
1419 if(err) | |
1420 return err; | |
1421 } | |
1422 | |
1423 spectral_to_sample(ac); | |
1424 | |
7539 | 1425 if (!ac->is_saved) { |
1426 ac->is_saved = 1; | |
1427 *data_size = 0; | |
7580 | 1428 return buf_size; |
7539 | 1429 } |
1430 | |
1431 data_size_tmp = 1024 * avccontext->channels * sizeof(int16_t); | |
1432 if(*data_size < data_size_tmp) { | |
1433 av_log(avccontext, AV_LOG_ERROR, | |
1434 "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n", | |
1435 *data_size, data_size_tmp); | |
1436 return -1; | |
1437 } | |
1438 *data_size = data_size_tmp; | |
1439 | |
1440 ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, 1024, avccontext->channels); | |
1441 | |
1442 return buf_size; | |
1443 } | |
1444 | |
7501 | 1445 static av_cold int aac_decode_close(AVCodecContext * avccontext) { |
1446 AACContext * ac = avccontext->priv_data; | |
7540 | 1447 int i, type; |
7501 | 1448 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1449 for (i = 0; i < MAX_ELEM_ID; i++) { |
7540 | 1450 for(type = 0; type < 4; type++) |
1451 av_freep(&ac->che[type][i]); | |
7501 | 1452 } |
1453 | |
1454 ff_mdct_end(&ac->mdct); | |
1455 ff_mdct_end(&ac->mdct_small); | |
1456 return 0 ; | |
1457 } | |
1458 | |
1459 AVCodec aac_decoder = { | |
1460 "aac", | |
1461 CODEC_TYPE_AUDIO, | |
1462 CODEC_ID_AAC, | |
1463 sizeof(AACContext), | |
1464 aac_decode_init, | |
1465 NULL, | |
1466 aac_decode_close, | |
1467 aac_decode_frame, | |
1468 .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"), | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1469 .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, |
7501 | 1470 }; |