Mercurial > libavcodec.hg
annotate aac.c @ 8991:ca768cb2bfb6 libavcodec
Use last decoded SPS as current SPS in order to parse picture timing SEI
correctly. This works around an apparent H.264 standard deficiency.
Patch by Ivan Schreter, schreter gmx net
author | cehoyos |
---|---|
date | Fri, 20 Feb 2009 16:20:01 +0000 |
parents | 70ea65c17597 |
children | 0cffed11ee33 |
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 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8590
diff
changeset
|
24 * @file libavcodec/aac.c |
7501 | 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 | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
44 * Y frequency domain prediction |
7501 | 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" | |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8200
diff
changeset
|
80 #include "internal.h" |
7501 | 81 #include "bitstream.h" |
82 #include "dsputil.h" | |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
83 #include "lpc.h" |
7501 | 84 |
85 #include "aac.h" | |
86 #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
|
87 #include "aacdectab.h" |
7501 | 88 #include "mpeg4audio.h" |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
89 #include "aac_parser.h" |
7501 | 90 |
91 #include <assert.h> | |
92 #include <errno.h> | |
93 #include <math.h> | |
94 #include <string.h> | |
95 | |
96 static VLC vlc_scalefactors; | |
97 static VLC vlc_spectral[11]; | |
98 | |
99 | |
7539 | 100 /** |
7578 | 101 * Configure output channel order based on the current program configuration element. |
102 * | |
103 * @param che_pos current channel position configuration | |
104 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
105 * | |
106 * @return Returns error status. 0 - OK, !0 - error | |
107 */ | |
108 static int output_configure(AACContext *ac, enum ChannelPosition che_pos[4][MAX_ELEM_ID], | |
109 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]) { | |
110 AVCodecContext *avctx = ac->avccontext; | |
111 int i, type, channels = 0; | |
112 | |
113 if(!memcmp(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]))) | |
114 return 0; /* no change */ | |
115 | |
116 memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
117 | |
118 /* Allocate or free elements depending on if they are in the | |
119 * current program configuration. | |
120 * | |
121 * Set up default 1:1 output mapping. | |
122 * | |
123 * 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
|
124 * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ] |
7578 | 125 */ |
126 | |
127 for(i = 0; i < MAX_ELEM_ID; i++) { | |
128 for(type = 0; type < 4; type++) { | |
129 if(che_pos[type][i]) { | |
130 if(!ac->che[type][i] && !(ac->che[type][i] = av_mallocz(sizeof(ChannelElement)))) | |
131 return AVERROR(ENOMEM); | |
132 if(type != TYPE_CCE) { | |
133 ac->output_data[channels++] = ac->che[type][i]->ch[0].ret; | |
134 if(type == TYPE_CPE) { | |
135 ac->output_data[channels++] = ac->che[type][i]->ch[1].ret; | |
136 } | |
137 } | |
138 } else | |
139 av_freep(&ac->che[type][i]); | |
140 } | |
141 } | |
142 | |
143 avctx->channels = channels; | |
144 return 0; | |
145 } | |
146 | |
147 /** | |
7539 | 148 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit. |
149 * | |
150 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present. | |
151 * @param sce_map mono (Single Channel Element) map | |
152 * @param type speaker type/position for these channels | |
153 */ | |
154 static void decode_channel_map(enum ChannelPosition *cpe_map, | |
155 enum ChannelPosition *sce_map, enum ChannelPosition type, GetBitContext * gb, int n) { | |
156 while(n--) { | |
157 enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map | |
158 map[get_bits(gb, 4)] = type; | |
159 } | |
160 } | |
161 | |
162 /** | |
163 * Decode program configuration element; reference: table 4.2. | |
164 * | |
165 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
166 * | |
167 * @return Returns error status. 0 - OK, !0 - error | |
168 */ | |
169 static int decode_pce(AACContext * ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], | |
170 GetBitContext * gb) { | |
8412
2d48043ab521
AAC: Don't write an illegal sampling_index in a PCE to the MPEG4AudioConfig
superdump
parents:
8286
diff
changeset
|
171 int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index; |
7539 | 172 |
173 skip_bits(gb, 2); // object_type | |
174 | |
8412
2d48043ab521
AAC: Don't write an illegal sampling_index in a PCE to the MPEG4AudioConfig
superdump
parents:
8286
diff
changeset
|
175 sampling_index = get_bits(gb, 4); |
8812 | 176 if(sampling_index > 12) { |
7539 | 177 av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); |
178 return -1; | |
179 } | |
8412
2d48043ab521
AAC: Don't write an illegal sampling_index in a PCE to the MPEG4AudioConfig
superdump
parents:
8286
diff
changeset
|
180 ac->m4ac.sampling_index = sampling_index; |
7539 | 181 ac->m4ac.sample_rate = ff_mpeg4audio_sample_rates[ac->m4ac.sampling_index]; |
7501 | 182 num_front = get_bits(gb, 4); |
183 num_side = get_bits(gb, 4); | |
184 num_back = get_bits(gb, 4); | |
185 num_lfe = get_bits(gb, 2); | |
186 num_assoc_data = get_bits(gb, 3); | |
187 num_cc = get_bits(gb, 4); | |
188 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
189 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
|
190 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
|
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, 4); // stereo_mixdown_tag |
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 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
|
195 skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround |
7501 | 196 |
7523
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(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
|
198 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
|
199 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
|
200 decode_channel_map(NULL, new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE, gb, num_lfe ); |
7501 | 201 |
202 skip_bits_long(gb, 4 * num_assoc_data); | |
203 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
204 decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC, gb, num_cc ); |
7501 | 205 |
206 align_get_bits(gb); | |
207 | |
208 /* comment field, first byte is length */ | |
209 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
|
210 return 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
211 } |
7501 | 212 |
7539 | 213 /** |
214 * Set up channel positions based on a default channel configuration | |
215 * as specified in table 1.17. | |
216 * | |
217 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
218 * | |
219 * @return Returns error status. 0 - OK, !0 - error | |
220 */ | |
221 static int set_default_channel_config(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], | |
222 int channel_config) | |
223 { | |
224 if(channel_config < 1 || channel_config > 7) { | |
225 av_log(ac->avccontext, AV_LOG_ERROR, "invalid default channel configuration (%d)\n", | |
226 channel_config); | |
227 return -1; | |
228 } | |
229 | |
230 /* default channel configurations: | |
231 * | |
232 * 1ch : front center (mono) | |
233 * 2ch : L + R (stereo) | |
234 * 3ch : front center + L + R | |
235 * 4ch : front center + L + R + back center | |
236 * 5ch : front center + L + R + back stereo | |
237 * 6ch : front center + L + R + back stereo + LFE | |
238 * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE | |
239 */ | |
240 | |
241 if(channel_config != 2) | |
242 new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono) | |
243 if(channel_config > 1) | |
244 new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo) | |
245 if(channel_config == 4) | |
246 new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK; // back center | |
247 if(channel_config > 4) | |
248 new_che_pos[TYPE_CPE][(channel_config == 7) + 1] | |
249 = AAC_CHANNEL_BACK; // back stereo | |
250 if(channel_config > 5) | |
251 new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE; // LFE | |
252 if(channel_config == 7) | |
253 new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right | |
254 | |
255 return 0; | |
256 } | |
257 | |
7578 | 258 /** |
259 * Decode GA "General Audio" specific configuration; reference: table 4.1. | |
260 * | |
261 * @return Returns error status. 0 - OK, !0 - error | |
262 */ | |
263 static int decode_ga_specific_config(AACContext * ac, GetBitContext * gb, int channel_config) { | |
264 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; | |
265 int extension_flag, ret; | |
266 | |
267 if(get_bits1(gb)) { // frameLengthFlag | |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8200
diff
changeset
|
268 ff_log_missing_feature(ac->avccontext, "960/120 MDCT window is", 1); |
7539 | 269 return -1; |
270 } | |
271 | |
272 if (get_bits1(gb)) // dependsOnCoreCoder | |
273 skip_bits(gb, 14); // coreCoderDelay | |
274 extension_flag = get_bits1(gb); | |
275 | |
276 if(ac->m4ac.object_type == AOT_AAC_SCALABLE || | |
277 ac->m4ac.object_type == AOT_ER_AAC_SCALABLE) | |
278 skip_bits(gb, 3); // layerNr | |
279 | |
280 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
281 if (channel_config == 0) { | |
282 skip_bits(gb, 4); // element_instance_tag | |
283 if((ret = decode_pce(ac, new_che_pos, gb))) | |
284 return ret; | |
285 } else { | |
286 if((ret = set_default_channel_config(ac, new_che_pos, channel_config))) | |
287 return ret; | |
288 } | |
289 if((ret = output_configure(ac, ac->che_pos, new_che_pos))) | |
290 return ret; | |
291 | |
292 if (extension_flag) { | |
293 switch (ac->m4ac.object_type) { | |
294 case AOT_ER_BSAC: | |
295 skip_bits(gb, 5); // numOfSubFrame | |
296 skip_bits(gb, 11); // layer_length | |
297 break; | |
298 case AOT_ER_AAC_LC: | |
299 case AOT_ER_AAC_LTP: | |
300 case AOT_ER_AAC_SCALABLE: | |
301 case AOT_ER_AAC_LD: | |
302 skip_bits(gb, 3); /* aacSectionDataResilienceFlag | |
303 * aacScalefactorDataResilienceFlag | |
304 * aacSpectralDataResilienceFlag | |
305 */ | |
306 break; | |
307 } | |
308 skip_bits1(gb); // extensionFlag3 (TBD in version 3) | |
309 } | |
310 return 0; | |
311 } | |
312 | |
313 /** | |
314 * Decode audio specific configuration; reference: table 1.13. | |
315 * | |
316 * @param data pointer to AVCodecContext extradata | |
317 * @param data_size size of AVCCodecContext extradata | |
318 * | |
319 * @return Returns error status. 0 - OK, !0 - error | |
320 */ | |
321 static int decode_audio_specific_config(AACContext * ac, void *data, int data_size) { | |
322 GetBitContext gb; | |
323 int i; | |
324 | |
325 init_get_bits(&gb, data, data_size * 8); | |
326 | |
327 if((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0) | |
328 return -1; | |
8812 | 329 if(ac->m4ac.sampling_index > 12) { |
7539 | 330 av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); |
331 return -1; | |
332 } | |
333 | |
334 skip_bits_long(&gb, i); | |
335 | |
336 switch (ac->m4ac.object_type) { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
337 case AOT_AAC_MAIN: |
7539 | 338 case AOT_AAC_LC: |
339 if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config)) | |
340 return -1; | |
341 break; | |
342 default: | |
343 av_log(ac->avccontext, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n", | |
344 ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type); | |
345 return -1; | |
346 } | |
347 return 0; | |
348 } | |
349 | |
7578 | 350 /** |
351 * linear congruential pseudorandom number generator | |
352 * | |
353 * @param previous_val pointer to the current state of the generator | |
354 * | |
355 * @return Returns a 32-bit pseudorandom integer | |
356 */ | |
357 static av_always_inline int lcg_random(int previous_val) { | |
358 return previous_val * 1664525 + 1013904223; | |
359 } | |
360 | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
361 static void reset_predict_state(PredictorState * ps) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
362 ps->r0 = 0.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
363 ps->r1 = 0.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
364 ps->cor0 = 0.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
365 ps->cor1 = 0.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
366 ps->var0 = 1.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
367 ps->var1 = 1.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
368 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
369 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
370 static void reset_all_predictors(PredictorState * ps) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
371 int i; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
372 for (i = 0; i < MAX_PREDICTORS; i++) |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
373 reset_predict_state(&ps[i]); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
374 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
375 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
376 static void reset_predictor_group(PredictorState * ps, int group_num) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
377 int i; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
378 for (i = group_num-1; i < MAX_PREDICTORS; i+=30) |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
379 reset_predict_state(&ps[i]); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
380 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
381 |
7501 | 382 static av_cold int aac_decode_init(AVCodecContext * avccontext) { |
383 AACContext * ac = avccontext->priv_data; | |
384 int i; | |
385 | |
386 ac->avccontext = avccontext; | |
387 | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
388 if (avccontext->extradata_size > 0) { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
389 if(decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size)) |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
390 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
391 avccontext->sample_rate = ac->m4ac.sample_rate; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
392 } else if (avccontext->channels > 0) { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
393 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
394 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
395 if(set_default_channel_config(ac, new_che_pos, avccontext->channels - (avccontext->channels == 8))) |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
396 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
397 if(output_configure(ac, ac->che_pos, new_che_pos)) |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
398 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
399 ac->m4ac.sample_rate = avccontext->sample_rate; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
400 } else { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
401 ff_log_missing_feature(ac->avccontext, "Implicit channel configuration is", 0); |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
402 return -1; |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
403 } |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
404 |
7539 | 405 avccontext->sample_fmt = SAMPLE_FMT_S16; |
7501 | 406 avccontext->frame_size = 1024; |
407 | |
408 AAC_INIT_VLC_STATIC( 0, 144); | |
409 AAC_INIT_VLC_STATIC( 1, 114); | |
410 AAC_INIT_VLC_STATIC( 2, 188); | |
411 AAC_INIT_VLC_STATIC( 3, 180); | |
412 AAC_INIT_VLC_STATIC( 4, 172); | |
413 AAC_INIT_VLC_STATIC( 5, 140); | |
414 AAC_INIT_VLC_STATIC( 6, 168); | |
415 AAC_INIT_VLC_STATIC( 7, 114); | |
416 AAC_INIT_VLC_STATIC( 8, 262); | |
417 AAC_INIT_VLC_STATIC( 9, 248); | |
418 AAC_INIT_VLC_STATIC(10, 384); | |
419 | |
420 dsputil_init(&ac->dsp, avccontext); | |
421 | |
7539 | 422 ac->random_state = 0x1f2e3d4c; |
423 | |
7501 | 424 // -1024 - Compensate wrong IMDCT method. |
425 // 32768 - Required to scale values to the correct range for the bias method | |
426 // for float to int16 conversion. | |
427 | |
428 if(ac->dsp.float_to_int16 == ff_float_to_int16_c) { | |
429 ac->add_bias = 385.0f; | |
430 ac->sf_scale = 1. / (-1024. * 32768.); | |
431 ac->sf_offset = 0; | |
432 } else { | |
433 ac->add_bias = 0.0f; | |
434 ac->sf_scale = 1. / -1024.; | |
435 ac->sf_offset = 60; | |
436 } | |
437 | |
8590 | 438 #if !CONFIG_HARDCODED_TABLES |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
439 for (i = 0; i < 428; i++) |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
440 ff_aac_pow2sf_tab[i] = pow(2, (i - 200)/4.); |
7501 | 441 #endif /* CONFIG_HARDCODED_TABLES */ |
442 | |
8042 | 443 INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code), |
7501 | 444 ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]), |
445 ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]), | |
446 352); | |
447 | |
448 ff_mdct_init(&ac->mdct, 11, 1); | |
449 ff_mdct_init(&ac->mdct_small, 8, 1); | |
7581 | 450 // window initialization |
451 ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024); | |
452 ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128); | |
453 ff_sine_window_init(ff_sine_1024, 1024); | |
454 ff_sine_window_init(ff_sine_128, 128); | |
455 | |
7501 | 456 return 0; |
457 } | |
458 | |
7539 | 459 /** |
460 * Skip data_stream_element; reference: table 4.10. | |
461 */ | |
462 static void skip_data_stream_element(GetBitContext * gb) { | |
7501 | 463 int byte_align = get_bits1(gb); |
464 int count = get_bits(gb, 8); | |
465 if (count == 255) | |
466 count += get_bits(gb, 8); | |
467 if (byte_align) | |
468 align_get_bits(gb); | |
469 skip_bits_long(gb, 8 * count); | |
470 } | |
471 | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
472 static int decode_prediction(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
473 int sfb; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
474 if (get_bits1(gb)) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
475 ics->predictor_reset_group = get_bits(gb, 5); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
476 if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
477 av_log(ac->avccontext, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n"); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
478 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
479 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
480 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
481 for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->m4ac.sampling_index]); sfb++) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
482 ics->prediction_used[sfb] = get_bits1(gb); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
483 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
484 return 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
485 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
486 |
7501 | 487 /** |
7539 | 488 * Decode Individual Channel Stream info; reference: table 4.6. |
489 * | |
490 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
491 */ | |
492 static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb, int common_window) { | |
493 if (get_bits1(gb)) { | |
494 av_log(ac->avccontext, AV_LOG_ERROR, "Reserved bit set.\n"); | |
495 memset(ics, 0, sizeof(IndividualChannelStream)); | |
496 return -1; | |
497 } | |
498 ics->window_sequence[1] = ics->window_sequence[0]; | |
499 ics->window_sequence[0] = get_bits(gb, 2); | |
500 ics->use_kb_window[1] = ics->use_kb_window[0]; | |
501 ics->use_kb_window[0] = get_bits1(gb); | |
502 ics->num_window_groups = 1; | |
503 ics->group_len[0] = 1; | |
7581 | 504 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
505 int i; | |
506 ics->max_sfb = get_bits(gb, 4); | |
507 for (i = 0; i < 7; i++) { | |
508 if (get_bits1(gb)) { | |
509 ics->group_len[ics->num_window_groups-1]++; | |
510 } else { | |
511 ics->num_window_groups++; | |
512 ics->group_len[ics->num_window_groups-1] = 1; | |
513 } | |
514 } | |
515 ics->num_windows = 8; | |
516 ics->swb_offset = swb_offset_128[ac->m4ac.sampling_index]; | |
517 ics->num_swb = ff_aac_num_swb_128[ac->m4ac.sampling_index]; | |
518 ics->tns_max_bands = tns_max_bands_128[ac->m4ac.sampling_index]; | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
519 ics->predictor_present = 0; |
7581 | 520 } else { |
521 ics->max_sfb = get_bits(gb, 6); | |
522 ics->num_windows = 1; | |
523 ics->swb_offset = swb_offset_1024[ac->m4ac.sampling_index]; | |
524 ics->num_swb = ff_aac_num_swb_1024[ac->m4ac.sampling_index]; | |
525 ics->tns_max_bands = tns_max_bands_1024[ac->m4ac.sampling_index]; | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
526 ics->predictor_present = get_bits1(gb); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
527 ics->predictor_reset_group = 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
528 if (ics->predictor_present) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
529 if (ac->m4ac.object_type == AOT_AAC_MAIN) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
530 if (decode_prediction(ac, ics, gb)) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
531 memset(ics, 0, sizeof(IndividualChannelStream)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
532 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
533 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
534 } else if (ac->m4ac.object_type == AOT_AAC_LC) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
535 av_log(ac->avccontext, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n"); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
536 memset(ics, 0, sizeof(IndividualChannelStream)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
537 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
538 } else { |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8200
diff
changeset
|
539 ff_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1); |
8200 | 540 memset(ics, 0, sizeof(IndividualChannelStream)); |
541 return -1; | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
542 } |
7578 | 543 } |
544 } | |
545 | |
546 if(ics->max_sfb > ics->num_swb) { | |
547 av_log(ac->avccontext, AV_LOG_ERROR, | |
548 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n", | |
549 ics->max_sfb, ics->num_swb); | |
550 memset(ics, 0, sizeof(IndividualChannelStream)); | |
551 return -1; | |
552 } | |
553 | |
7539 | 554 return 0; |
555 } | |
556 | |
557 /** | |
558 * Decode band types (section_data payload); reference: table 4.46. | |
559 * | |
560 * @param band_type array of the used band type | |
561 * @param band_type_run_end array of the last scalefactor band of a band type run | |
562 * | |
563 * @return Returns error status. 0 - OK, !0 - error | |
564 */ | |
565 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
|
566 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
|
567 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
|
568 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
|
569 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
|
570 int k = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
571 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
|
572 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
|
573 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
|
574 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
|
575 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
|
576 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
|
577 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
578 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
579 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
|
580 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
|
581 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
|
582 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
|
583 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
|
584 "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
|
585 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
|
586 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
587 } |
7581 | 588 for (; k < sect_len; k++) { |
589 band_type [idx] = sect_band_type; | |
590 band_type_run_end[idx++] = sect_len; | |
591 } | |
7539 | 592 } |
593 } | |
594 return 0; | |
595 } | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
596 |
7539 | 597 /** |
598 * 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
|
599 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
600 * @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
|
601 * @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
|
602 * @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
|
603 * @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
|
604 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
605 * @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
|
606 */ |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
607 static int decode_scalefactors(AACContext * ac, float sf[120], GetBitContext * gb, |
7540 | 608 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
|
609 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
|
610 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
|
611 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
|
612 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
|
613 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
|
614 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
|
615 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
|
616 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
|
617 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
|
618 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
|
619 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
|
620 sf[idx] = 0.; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
621 }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
|
622 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
|
623 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
|
624 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
|
625 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
|
626 "%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
|
627 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
628 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
629 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
|
630 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
631 }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
|
632 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
|
633 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
|
634 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
|
635 else |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
636 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
|
637 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
|
638 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
|
639 "%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
|
640 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
641 } |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
642 sf[idx] = -ff_aac_pow2sf_tab[ offset[1] + sf_offset + 100]; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
643 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
644 }else { |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
645 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
|
646 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
|
647 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
|
648 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
|
649 "%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
|
650 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
651 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
652 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
|
653 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
654 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
655 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
656 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
657 return 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
658 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
659 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
660 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
661 * 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
|
662 */ |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
663 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
|
664 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
|
665 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
|
666 pulse_swb = get_bits(gb, 6); |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
667 if (pulse_swb >= num_swb) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
668 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
669 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
|
670 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
|
671 if (pulse->pos[0] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
672 return -1; |
7580 | 673 pulse->amp[0] = get_bits(gb, 4); |
674 for (i = 1; i < pulse->num_pulse; i++) { | |
675 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
|
676 if (pulse->pos[i] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
677 return -1; |
7580 | 678 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
|
679 } |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
680 return 0; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
681 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
682 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
683 /** |
7609 | 684 * Decode Temporal Noise Shaping data; reference: table 4.48. |
685 * | |
686 * @return Returns error status. 0 - OK, !0 - error | |
687 */ | |
688 static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns, | |
689 GetBitContext * gb, const IndividualChannelStream * ics) { | |
690 int w, filt, i, coef_len, coef_res, coef_compress; | |
691 const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE; | |
692 const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12; | |
693 for (w = 0; w < ics->num_windows; w++) { | |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
694 if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) { |
7609 | 695 coef_res = get_bits1(gb); |
696 | |
7638 | 697 for (filt = 0; filt < tns->n_filt[w]; filt++) { |
698 int tmp2_idx; | |
699 tns->length[w][filt] = get_bits(gb, 6 - 2*is8); | |
7609 | 700 |
7638 | 701 if ((tns->order[w][filt] = get_bits(gb, 5 - 2*is8)) > tns_max_order) { |
702 av_log(ac->avccontext, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.", | |
703 tns->order[w][filt], tns_max_order); | |
704 tns->order[w][filt] = 0; | |
705 return -1; | |
706 } | |
7850
77030651ddd0
Only read some of TNS bitstream data in the case that the TNS filter order is
superdump
parents:
7845
diff
changeset
|
707 if (tns->order[w][filt]) { |
7851 | 708 tns->direction[w][filt] = get_bits1(gb); |
709 coef_compress = get_bits1(gb); | |
710 coef_len = coef_res + 3 - coef_compress; | |
711 tmp2_idx = 2*coef_compress + coef_res; | |
7638 | 712 |
7851 | 713 for (i = 0; i < tns->order[w][filt]; i++) |
714 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
|
715 } |
7609 | 716 } |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
717 } |
7609 | 718 } |
719 return 0; | |
720 } | |
721 | |
722 /** | |
7539 | 723 * Decode Mid/Side data; reference: table 4.54. |
724 * | |
725 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
726 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
727 * [3] reserved for scalable AAC | |
728 */ | |
729 static void decode_mid_side_stereo(ChannelElement * cpe, GetBitContext * gb, | |
730 int ms_present) { | |
7578 | 731 int idx; |
732 if (ms_present == 1) { | |
733 for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++) | |
734 cpe->ms_mask[idx] = get_bits1(gb); | |
735 } else if (ms_present == 2) { | |
736 memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0])); | |
737 } | |
738 } | |
7539 | 739 |
740 /** | |
7581 | 741 * Decode spectral data; reference: table 4.50. |
742 * Dequantize and scale spectral data; reference: 4.6.3.3. | |
743 * | |
744 * @param coef array of dequantized, scaled spectral data | |
745 * @param sf array of scalefactors or intensity stereo positions | |
746 * @param pulse_present set if pulses are present | |
747 * @param pulse pointer to pulse data struct | |
748 * @param band_type array of the used band type | |
749 * | |
750 * @return Returns error status. 0 - OK, !0 - error | |
751 */ | |
752 static int decode_spectrum_and_dequant(AACContext * ac, float coef[1024], GetBitContext * gb, float sf[120], | |
753 int pulse_present, const Pulse * pulse, const IndividualChannelStream * ics, enum BandType band_type[120]) { | |
754 int i, k, g, idx = 0; | |
755 const int c = 1024/ics->num_windows; | |
756 const uint16_t * offsets = ics->swb_offset; | |
757 float *coef_base = coef; | |
8284 | 758 static const float sign_lookup[] = { 1.0f, -1.0f }; |
7581 | 759 |
760 for (g = 0; g < ics->num_windows; g++) | |
761 memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float)*(c - offsets[ics->max_sfb])); | |
762 | |
763 for (g = 0; g < ics->num_window_groups; g++) { | |
764 for (i = 0; i < ics->max_sfb; i++, idx++) { | |
765 const int cur_band_type = band_type[idx]; | |
766 const int dim = cur_band_type >= FIRST_PAIR_BT ? 2 : 4; | |
767 const int is_cb_unsigned = IS_CODEBOOK_UNSIGNED(cur_band_type); | |
768 int group; | |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
769 if (cur_band_type == ZERO_BT || cur_band_type == INTENSITY_BT2 || cur_band_type == INTENSITY_BT) { |
7581 | 770 for (group = 0; group < ics->group_len[g]; group++) { |
771 memset(coef + group * 128 + offsets[i], 0, (offsets[i+1] - offsets[i])*sizeof(float)); | |
772 } | |
773 }else if (cur_band_type == NOISE_BT) { | |
774 for (group = 0; group < ics->group_len[g]; group++) { | |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
775 float scale; |
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
776 float band_energy = 0; |
7581 | 777 for (k = offsets[i]; k < offsets[i+1]; k++) { |
778 ac->random_state = lcg_random(ac->random_state); | |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
779 coef[group*128+k] = ac->random_state; |
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
780 band_energy += coef[group*128+k]*coef[group*128+k]; |
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
781 } |
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
782 scale = sf[idx] / sqrtf(band_energy); |
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
783 for (k = offsets[i]; k < offsets[i+1]; k++) { |
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
784 coef[group*128+k] *= scale; |
7581 | 785 } |
786 } | |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
787 }else { |
7581 | 788 for (group = 0; group < ics->group_len[g]; group++) { |
789 for (k = offsets[i]; k < offsets[i+1]; k += dim) { | |
790 const int index = get_vlc2(gb, vlc_spectral[cur_band_type - 1].table, 6, 3); | |
791 const int coef_tmp_idx = (group << 7) + k; | |
792 const float *vq_ptr; | |
793 int j; | |
794 if(index >= ff_aac_spectral_sizes[cur_band_type - 1]) { | |
795 av_log(ac->avccontext, AV_LOG_ERROR, | |
796 "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n", | |
797 cur_band_type - 1, index, ff_aac_spectral_sizes[cur_band_type - 1]); | |
798 return -1; | |
799 } | |
800 vq_ptr = &ff_aac_codebook_vectors[cur_band_type - 1][index * dim]; | |
801 if (is_cb_unsigned) { | |
8284 | 802 if (vq_ptr[0]) coef[coef_tmp_idx ] = sign_lookup[get_bits1(gb)]; |
803 if (vq_ptr[1]) coef[coef_tmp_idx + 1] = sign_lookup[get_bits1(gb)]; | |
8283
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
804 if (dim == 4) { |
8284 | 805 if (vq_ptr[2]) coef[coef_tmp_idx + 2] = sign_lookup[get_bits1(gb)]; |
806 if (vq_ptr[3]) coef[coef_tmp_idx + 3] = sign_lookup[get_bits1(gb)]; | |
8283
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
807 } |
7581 | 808 }else { |
8283
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
809 coef[coef_tmp_idx ] = 1.0f; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
810 coef[coef_tmp_idx + 1] = 1.0f; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
811 if (dim == 4) { |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
812 coef[coef_tmp_idx + 2] = 1.0f; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
813 coef[coef_tmp_idx + 3] = 1.0f; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
814 } |
7581 | 815 } |
816 if (cur_band_type == ESC_BT) { | |
817 for (j = 0; j < 2; j++) { | |
818 if (vq_ptr[j] == 64.0f) { | |
819 int n = 4; | |
820 /* The total length of escape_sequence must be < 22 bits according | |
821 to the specification (i.e. max is 11111111110xxxxxxxxxx). */ | |
822 while (get_bits1(gb) && n < 15) n++; | |
823 if(n == 15) { | |
824 av_log(ac->avccontext, AV_LOG_ERROR, "error in spectral data, ESC overflow\n"); | |
825 return -1; | |
826 } | |
827 n = (1<<n) + get_bits(gb, n); | |
8282 | 828 coef[coef_tmp_idx + j] *= cbrtf(n) * n; |
7581 | 829 }else |
830 coef[coef_tmp_idx + j] *= vq_ptr[j]; | |
831 } | |
832 }else | |
8283
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
833 { |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
834 coef[coef_tmp_idx ] *= vq_ptr[0]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
835 coef[coef_tmp_idx + 1] *= vq_ptr[1]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
836 if (dim == 4) { |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
837 coef[coef_tmp_idx + 2] *= vq_ptr[2]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
838 coef[coef_tmp_idx + 3] *= vq_ptr[3]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
839 } |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
840 } |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
841 coef[coef_tmp_idx ] *= sf[idx]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
842 coef[coef_tmp_idx + 1] *= sf[idx]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
843 if (dim == 4) { |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
844 coef[coef_tmp_idx + 2] *= sf[idx]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
845 coef[coef_tmp_idx + 3] *= sf[idx]; |
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
846 } |
7581 | 847 } |
848 } | |
849 } | |
850 } | |
851 coef += ics->group_len[g]<<7; | |
852 } | |
853 | |
854 if (pulse_present) { | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
855 idx = 0; |
7581 | 856 for(i = 0; i < pulse->num_pulse; i++){ |
857 float co = coef_base[ pulse->pos[i] ]; | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
858 while(offsets[idx + 1] <= pulse->pos[i]) |
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
859 idx++; |
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
860 if (band_type[idx] != NOISE_BT && sf[idx]) { |
7858 | 861 float ico = -pulse->amp[i]; |
862 if (co) { | |
863 co /= sf[idx]; | |
864 ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico); | |
865 } | |
866 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
|
867 } |
7581 | 868 } |
869 } | |
870 return 0; | |
871 } | |
872 | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
873 static av_always_inline float flt16_round(float pf) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
874 int exp; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
875 pf = frexpf(pf, &exp); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
876 pf = ldexpf(roundf(ldexpf(pf, 8)), exp-8); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
877 return pf; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
878 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
879 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
880 static av_always_inline float flt16_even(float pf) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
881 int exp; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
882 pf = frexpf(pf, &exp); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
883 pf = ldexpf(rintf(ldexpf(pf, 8)), exp-8); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
884 return pf; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
885 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
886 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
887 static av_always_inline float flt16_trunc(float pf) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
888 int exp; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
889 pf = frexpf(pf, &exp); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
890 pf = ldexpf(truncf(ldexpf(pf, 8)), exp-8); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
891 return pf; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
892 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
893 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
894 static void predict(AACContext * ac, PredictorState * ps, float* coef, int output_enable) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
895 const float a = 0.953125; // 61.0/64 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
896 const float alpha = 0.90625; // 29.0/32 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
897 float e0, e1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
898 float pv; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
899 float k1, k2; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
900 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
901 k1 = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
902 k2 = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
903 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
904 pv = flt16_round(k1 * ps->r0 + k2 * ps->r1); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
905 if (output_enable) |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
906 *coef += pv * ac->sf_scale; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
907 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
908 e0 = *coef / ac->sf_scale; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
909 e1 = e0 - k1 * ps->r0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
910 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
911 ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
912 ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5 * (ps->r1 * ps->r1 + e1 * e1)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
913 ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
914 ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5 * (ps->r0 * ps->r0 + e0 * e0)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
915 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
916 ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
917 ps->r0 = flt16_trunc(a * e0); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
918 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
919 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
920 /** |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
921 * Apply AAC-Main style frequency domain prediction. |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
922 */ |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
923 static void apply_prediction(AACContext * ac, SingleChannelElement * sce) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
924 int sfb, k; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
925 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
926 if (!sce->ics.predictor_initialized) { |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
927 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
928 sce->ics.predictor_initialized = 1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
929 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
930 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
931 if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
932 for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
933 for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) { |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
934 predict(ac, &sce->predictor_state[k], &sce->coeffs[k], |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
935 sce->ics.predictor_present && sce->ics.prediction_used[sfb]); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
936 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
937 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
938 if (sce->ics.predictor_reset_group) |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
939 reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
940 } else |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
941 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
942 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
943 |
7581 | 944 /** |
7539 | 945 * Decode an individual_channel_stream payload; reference: table 4.44. |
946 * | |
947 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
948 * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.) | |
949 * | |
950 * @return Returns error status. 0 - OK, !0 - error | |
951 */ | |
952 static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext * gb, int common_window, int scale_flag) { | |
953 Pulse pulse; | |
954 TemporalNoiseShaping * tns = &sce->tns; | |
955 IndividualChannelStream * ics = &sce->ics; | |
956 float * out = sce->coeffs; | |
957 int global_gain, pulse_present = 0; | |
958 | |
7580 | 959 /* This assignment is to silence a GCC warning about the variable being used |
960 * uninitialized when in fact it always is. | |
7539 | 961 */ |
962 pulse.num_pulse = 0; | |
963 | |
964 global_gain = get_bits(gb, 8); | |
965 | |
966 if (!common_window && !scale_flag) { | |
967 if (decode_ics_info(ac, ics, gb, 0) < 0) | |
968 return -1; | |
969 } | |
970 | |
971 if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0) | |
972 return -1; | |
973 if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0) | |
974 return -1; | |
975 | |
976 pulse_present = 0; | |
977 if (!scale_flag) { | |
978 if ((pulse_present = get_bits1(gb))) { | |
979 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { | |
980 av_log(ac->avccontext, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n"); | |
981 return -1; | |
982 } | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
983 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
|
984 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
|
985 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
986 } |
7539 | 987 } |
988 if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics)) | |
989 return -1; | |
990 if (get_bits1(gb)) { | |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8200
diff
changeset
|
991 ff_log_missing_feature(ac->avccontext, "SSR", 1); |
7539 | 992 return -1; |
993 } | |
994 } | |
995 | |
7580 | 996 if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0) |
7539 | 997 return -1; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
998 |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
999 if(ac->m4ac.object_type == AOT_AAC_MAIN && !common_window) |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1000 apply_prediction(ac, sce); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1001 |
7539 | 1002 return 0; |
1003 } | |
1004 | |
1005 /** | |
7581 | 1006 * Mid/Side stereo decoding; reference: 4.6.8.1.3. |
1007 */ | |
1008 static void apply_mid_side_stereo(ChannelElement * cpe) { | |
1009 const IndividualChannelStream * ics = &cpe->ch[0].ics; | |
1010 float *ch0 = cpe->ch[0].coeffs; | |
1011 float *ch1 = cpe->ch[1].coeffs; | |
1012 int g, i, k, group, idx = 0; | |
1013 const uint16_t * offsets = ics->swb_offset; | |
1014 for (g = 0; g < ics->num_window_groups; g++) { | |
1015 for (i = 0; i < ics->max_sfb; i++, idx++) { | |
1016 if (cpe->ms_mask[idx] && | |
1017 cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) { | |
1018 for (group = 0; group < ics->group_len[g]; group++) { | |
1019 for (k = offsets[i]; k < offsets[i+1]; k++) { | |
1020 float tmp = ch0[group*128 + k] - ch1[group*128 + k]; | |
1021 ch0[group*128 + k] += ch1[group*128 + k]; | |
1022 ch1[group*128 + k] = tmp; | |
1023 } | |
1024 } | |
1025 } | |
1026 } | |
1027 ch0 += ics->group_len[g]*128; | |
1028 ch1 += ics->group_len[g]*128; | |
1029 } | |
1030 } | |
1031 | |
1032 /** | |
1033 * intensity stereo decoding; reference: 4.6.8.2.3 | |
1034 * | |
1035 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
1036 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
1037 * [3] reserved for scalable AAC | |
1038 */ | |
1039 static void apply_intensity_stereo(ChannelElement * cpe, int ms_present) { | |
1040 const IndividualChannelStream * ics = &cpe->ch[1].ics; | |
1041 SingleChannelElement * sce1 = &cpe->ch[1]; | |
1042 float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs; | |
1043 const uint16_t * offsets = ics->swb_offset; | |
1044 int g, group, i, k, idx = 0; | |
1045 int c; | |
1046 float scale; | |
1047 for (g = 0; g < ics->num_window_groups; g++) { | |
1048 for (i = 0; i < ics->max_sfb;) { | |
1049 if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) { | |
1050 const int bt_run_end = sce1->band_type_run_end[idx]; | |
1051 for (; i < bt_run_end; i++, idx++) { | |
1052 c = -1 + 2 * (sce1->band_type[idx] - 14); | |
1053 if (ms_present) | |
1054 c *= 1 - 2 * cpe->ms_mask[idx]; | |
1055 scale = c * sce1->sf[idx]; | |
1056 for (group = 0; group < ics->group_len[g]; group++) | |
1057 for (k = offsets[i]; k < offsets[i+1]; k++) | |
1058 coef1[group*128 + k] = scale * coef0[group*128 + k]; | |
1059 } | |
1060 } else { | |
1061 int bt_run_end = sce1->band_type_run_end[idx]; | |
1062 idx += bt_run_end - i; | |
1063 i = bt_run_end; | |
1064 } | |
1065 } | |
1066 coef0 += ics->group_len[g]*128; | |
1067 coef1 += ics->group_len[g]*128; | |
1068 } | |
1069 } | |
1070 | |
1071 /** | |
7539 | 1072 * Decode a channel_pair_element; reference: table 4.4. |
1073 * | |
1074 * @param elem_id Identifies the instance of a syntax element. | |
1075 * | |
1076 * @return Returns error status. 0 - OK, !0 - error | |
1077 */ | |
1078 static int decode_cpe(AACContext * ac, GetBitContext * gb, int elem_id) { | |
1079 int i, ret, common_window, ms_present = 0; | |
1080 ChannelElement * cpe; | |
1081 | |
1082 cpe = ac->che[TYPE_CPE][elem_id]; | |
1083 common_window = get_bits1(gb); | |
1084 if (common_window) { | |
1085 if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1)) | |
1086 return -1; | |
1087 i = cpe->ch[1].ics.use_kb_window[0]; | |
1088 cpe->ch[1].ics = cpe->ch[0].ics; | |
1089 cpe->ch[1].ics.use_kb_window[1] = i; | |
1090 ms_present = get_bits(gb, 2); | |
1091 if(ms_present == 3) { | |
1092 av_log(ac->avccontext, AV_LOG_ERROR, "ms_present = 3 is reserved.\n"); | |
1093 return -1; | |
1094 } else if(ms_present) | |
1095 decode_mid_side_stereo(cpe, gb, ms_present); | |
1096 } | |
1097 if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0))) | |
1098 return ret; | |
1099 if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0))) | |
1100 return ret; | |
1101 | |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1102 if (common_window) { |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1103 if (ms_present) |
8414 | 1104 apply_mid_side_stereo(cpe); |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1105 if (ac->m4ac.object_type == AOT_AAC_MAIN) { |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1106 apply_prediction(ac, &cpe->ch[0]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1107 apply_prediction(ac, &cpe->ch[1]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1108 } |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1109 } |
7539 | 1110 |
7580 | 1111 apply_intensity_stereo(cpe, ms_present); |
7539 | 1112 return 0; |
1113 } | |
1114 | |
7581 | 1115 /** |
1116 * Decode coupling_channel_element; reference: table 4.8. | |
1117 * | |
1118 * @param elem_id Identifies the instance of a syntax element. | |
1119 * | |
1120 * @return Returns error status. 0 - OK, !0 - error | |
1121 */ | |
1122 static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) { | |
1123 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
|
1124 int c, g, sfb, ret; |
7581 | 1125 int sign; |
1126 float scale; | |
1127 SingleChannelElement * sce = &che->ch[0]; | |
1128 ChannelCoupling * coup = &che->coup; | |
1129 | |
7578 | 1130 coup->coupling_point = 2*get_bits1(gb); |
1131 coup->num_coupled = get_bits(gb, 3); | |
1132 for (c = 0; c <= coup->num_coupled; c++) { | |
1133 num_gain++; | |
1134 coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE; | |
1135 coup->id_select[c] = get_bits(gb, 4); | |
1136 if (coup->type[c] == TYPE_CPE) { | |
1137 coup->ch_select[c] = get_bits(gb, 2); | |
1138 if (coup->ch_select[c] == 3) | |
1139 num_gain++; | |
1140 } else | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1141 coup->ch_select[c] = 2; |
7578 | 1142 } |
1143 coup->coupling_point += get_bits1(gb); | |
1144 | |
1145 if (coup->coupling_point == 2) { | |
1146 av_log(ac->avccontext, AV_LOG_ERROR, | |
1147 "Independently switched CCE with 'invalid' domain signalled.\n"); | |
1148 memset(coup, 0, sizeof(ChannelCoupling)); | |
1149 return -1; | |
1150 } | |
1151 | |
1152 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
|
1153 scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3)); |
7578 | 1154 |
1155 if ((ret = decode_ics(ac, sce, gb, 0, 0))) | |
1156 return ret; | |
1157 | |
1158 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
|
1159 int idx = 0; |
7578 | 1160 int cge = 1; |
1161 int gain = 0; | |
1162 float gain_cache = 1.; | |
1163 if (c) { | |
1164 cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb); | |
1165 gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0; | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1166 gain_cache = pow(scale, -gain); |
7578 | 1167 } |
8822
01271e32d74e
Make set coup.gain[c][0] aand only coup.gain[c][0] is set for a independently switched CCE.
alexc
parents:
8814
diff
changeset
|
1168 if (coup->coupling_point == AFTER_IMDCT) { |
01271e32d74e
Make set coup.gain[c][0] aand only coup.gain[c][0] is set for a independently switched CCE.
alexc
parents:
8814
diff
changeset
|
1169 coup->gain[c][0] = gain_cache; |
01271e32d74e
Make set coup.gain[c][0] aand only coup.gain[c][0] is set for a independently switched CCE.
alexc
parents:
8814
diff
changeset
|
1170 } else { |
8823 | 1171 for (g = 0; g < sce->ics.num_window_groups; g++) { |
1172 for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) { | |
1173 if (sce->band_type[idx] != ZERO_BT) { | |
1174 if (!cge) { | |
1175 int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; | |
1176 if (t) { | |
1177 int s = 1; | |
1178 t = gain += t; | |
1179 if (sign) { | |
1180 s -= 2 * (t & 0x1); | |
1181 t >>= 1; | |
1182 } | |
1183 gain_cache = pow(scale, -t) * s; | |
7578 | 1184 } |
1185 } | |
8823 | 1186 coup->gain[c][idx] = gain_cache; |
7578 | 1187 } |
1188 } | |
7890 | 1189 } |
1190 } | |
7578 | 1191 } |
1192 return 0; | |
1193 } | |
1194 | |
7539 | 1195 /** |
1196 * 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
|
1197 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1198 * @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
|
1199 * @param cnt length of TYPE_FIL syntactic element in bytes |
7539 | 1200 * |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1201 * @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
|
1202 */ |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1203 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
|
1204 // TODO : sbr_extension implementation |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8200
diff
changeset
|
1205 ff_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
|
1206 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
|
1207 return cnt; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1208 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1209 |
7539 | 1210 /** |
7578 | 1211 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53. |
1212 * | |
1213 * @return Returns number of bytes consumed. | |
1214 */ | |
1215 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, GetBitContext * gb) { | |
1216 int i; | |
1217 int num_excl_chan = 0; | |
1218 | |
1219 do { | |
1220 for (i = 0; i < 7; i++) | |
1221 che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb); | |
1222 } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb)); | |
1223 | |
1224 return num_excl_chan / 7; | |
1225 } | |
1226 | |
1227 /** | |
7539 | 1228 * Decode dynamic range information; reference: table 4.52. |
1229 * | |
1230 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1231 * | |
1232 * @return Returns number of bytes consumed. | |
1233 */ | |
1234 static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext * gb, int cnt) { | |
1235 int n = 1; | |
1236 int drc_num_bands = 1; | |
1237 int i; | |
1238 | |
1239 /* pce_tag_present? */ | |
1240 if(get_bits1(gb)) { | |
1241 che_drc->pce_instance_tag = get_bits(gb, 4); | |
1242 skip_bits(gb, 4); // tag_reserved_bits | |
1243 n++; | |
1244 } | |
1245 | |
1246 /* excluded_chns_present? */ | |
1247 if(get_bits1(gb)) { | |
1248 n += decode_drc_channel_exclusions(che_drc, gb); | |
1249 } | |
1250 | |
1251 /* drc_bands_present? */ | |
1252 if (get_bits1(gb)) { | |
1253 che_drc->band_incr = get_bits(gb, 4); | |
1254 che_drc->interpolation_scheme = get_bits(gb, 4); | |
1255 n++; | |
1256 drc_num_bands += che_drc->band_incr; | |
1257 for (i = 0; i < drc_num_bands; i++) { | |
1258 che_drc->band_top[i] = get_bits(gb, 8); | |
1259 n++; | |
1260 } | |
1261 } | |
1262 | |
1263 /* prog_ref_level_present? */ | |
1264 if (get_bits1(gb)) { | |
1265 che_drc->prog_ref_level = get_bits(gb, 7); | |
1266 skip_bits1(gb); // prog_ref_level_reserved_bits | |
1267 n++; | |
1268 } | |
1269 | |
1270 for (i = 0; i < drc_num_bands; i++) { | |
1271 che_drc->dyn_rng_sgn[i] = get_bits1(gb); | |
1272 che_drc->dyn_rng_ctl[i] = get_bits(gb, 7); | |
1273 n++; | |
1274 } | |
1275 | |
1276 return n; | |
1277 } | |
1278 | |
1279 /** | |
1280 * Decode extension data (incomplete); reference: table 4.51. | |
1281 * | |
1282 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1283 * | |
1284 * @return Returns number of bytes consumed | |
1285 */ | |
1286 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
|
1287 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
|
1288 int res = cnt; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1289 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
|
1290 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
|
1291 crc_flag++; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1292 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
|
1293 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
|
1294 break; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1295 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
|
1296 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
|
1297 break; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1298 case EXT_FILL: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1299 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
|
1300 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
|
1301 default: |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1302 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
|
1303 break; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1304 }; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1305 return res; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1306 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1307 |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1308 /** |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1309 * 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
|
1310 * |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1311 * @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
|
1312 * @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
|
1313 */ |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1314 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
|
1315 const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb); |
7636 | 1316 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
|
1317 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
|
1318 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
|
1319 |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1320 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
|
1321 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
|
1322 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
|
1323 top = bottom; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1324 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
|
1325 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
|
1326 if (order == 0) |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1327 continue; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1328 |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1329 // tns_decode_coef |
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1330 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
|
1331 |
7609 | 1332 start = ics->swb_offset[FFMIN(bottom, mmm)]; |
1333 end = ics->swb_offset[FFMIN( top, mmm)]; | |
1334 if ((size = end - start) <= 0) | |
1335 continue; | |
1336 if (tns->direction[w][filt]) { | |
1337 inc = -1; start = end - 1; | |
1338 } else { | |
1339 inc = 1; | |
1340 } | |
1341 start += w * 128; | |
1342 | |
1343 // ar filter | |
1344 for (m = 0; m < size; m++, start += inc) | |
1345 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
|
1346 coef[start] -= coef[start - i*inc] * lpc[i-1]; |
7609 | 1347 } |
1348 } | |
1349 } | |
1350 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1351 /** |
7539 | 1352 * Conduct IMDCT and windowing. |
1353 */ | |
1354 static void imdct_and_windowing(AACContext * ac, SingleChannelElement * sce) { | |
1355 IndividualChannelStream * ics = &sce->ics; | |
1356 float * in = sce->coeffs; | |
1357 float * out = sce->ret; | |
1358 float * saved = sce->saved; | |
7580 | 1359 const float * swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; |
1360 const float * lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; | |
1361 const float * swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; | |
7539 | 1362 float * buf = ac->buf_mdct; |
8286
e06b2b848b74
AAC: move scratch array to context to ensure 16-byte alignment
mru
parents:
8284
diff
changeset
|
1363 float * temp = ac->temp; |
7539 | 1364 int i; |
1365 | |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1366 // imdct |
7578 | 1367 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
1368 if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) | |
1369 av_log(ac->avccontext, AV_LOG_WARNING, | |
1370 "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. " | |
1371 "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
|
1372 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
|
1373 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
|
1374 } else |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1375 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
|
1376 |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1377 /* window overlapping |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1378 * 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
|
1379 * 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
|
1380 * 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
|
1381 * 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
|
1382 */ |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1383 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
|
1384 (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
|
1385 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
|
1386 } else { |
7662 | 1387 for (i = 0; i < 448; i++) |
1388 out[i] = saved[i] + ac->add_bias; | |
7578 | 1389 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1390 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
|
1391 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
|
1392 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
|
1393 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
|
1394 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
|
1395 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
|
1396 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
|
1397 } else { |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1398 ac->dsp.vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, ac->add_bias, 64); |
7662 | 1399 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
|
1400 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
|
1401 } |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1402 } |
7578 | 1403 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1404 // buffer update |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1405 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
|
1406 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
|
1407 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
|
1408 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
|
1409 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
|
1410 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
|
1411 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
|
1412 } 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
|
1413 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
|
1414 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
|
1415 } 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
|
1416 memcpy( saved, buf + 512, 512 * sizeof(float)); |
7578 | 1417 } |
1418 } | |
1419 | |
7539 | 1420 /** |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1421 * 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
|
1422 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1423 * @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
|
1424 */ |
8006
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1425 static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index) { |
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1426 IndividualChannelStream * ics = &cce->ch[0].ics; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1427 const uint16_t * offsets = ics->swb_offset; |
8006
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1428 float * dest = target->coeffs; |
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1429 const float * src = cce->ch[0].coeffs; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1430 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
|
1431 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
|
1432 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
|
1433 "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
|
1434 return; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1435 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1436 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
|
1437 for (i = 0; i < ics->max_sfb; i++, idx++) { |
8006
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1438 if (cce->ch[0].band_type[idx] != ZERO_BT) { |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1439 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
|
1440 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
|
1441 // XXX dsputil-ize |
8006
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1442 dest[group*128+k] += cce->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
|
1443 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1444 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1445 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1446 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1447 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
|
1448 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
|
1449 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1450 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1451 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1452 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1453 * 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
|
1454 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1455 * @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
|
1456 */ |
8006
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1457 static void apply_independent_coupling(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index) { |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1458 int i; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1459 for (i = 0; i < 1024; i++) |
8006
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1460 target->ret[i] += cce->coup.gain[index][0] * (cce->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
|
1461 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1462 |
7581 | 1463 /** |
1464 * channel coupling transformation interface | |
1465 * | |
1466 * @param index index into coupling gain array | |
1467 * @param apply_coupling_method pointer to (in)dependent coupling function | |
1468 */ | |
1469 static void apply_channel_coupling(AACContext * ac, ChannelElement * cc, | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1470 enum RawDataBlockType type, int elem_id, enum CouplingPoint coupling_point, |
8006
c7c1e85d14bc
Rename variables to clarify the channel coupling element and corresponding
superdump
parents:
8004
diff
changeset
|
1471 void (*apply_coupling_method)(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index)) |
7581 | 1472 { |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1473 int i, c; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1474 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1475 for (i = 0; i < MAX_ELEM_ID; i++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1476 ChannelElement *cce = ac->che[TYPE_CCE][i]; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1477 int index = 0; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1478 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1479 if (cce && cce->coup.coupling_point == coupling_point) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1480 ChannelCoupling * coup = &cce->coup; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1481 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1482 for (c = 0; c <= coup->num_coupled; c++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1483 if (coup->type[c] == type && coup->id_select[c] == elem_id) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1484 if (coup->ch_select[c] != 1) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1485 apply_coupling_method(ac, &cc->ch[0], cce, index); |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1486 if (coup->ch_select[c] != 0) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1487 index++; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1488 } |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1489 if (coup->ch_select[c] != 2) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1490 apply_coupling_method(ac, &cc->ch[1], cce, index++); |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1491 } else |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1492 index += 1 + (coup->ch_select[c] == 3); |
7581 | 1493 } |
1494 } | |
1495 } | |
1496 } | |
1497 | |
1498 /** | |
1499 * Convert spectral data to float samples, applying all supported tools as appropriate. | |
1500 */ | |
1501 static void spectral_to_sample(AACContext * ac) { | |
8502 | 1502 int i, type; |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1503 for(type = 3; type >= 0; type--) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1504 for (i = 0; i < MAX_ELEM_ID; i++) { |
7581 | 1505 ChannelElement *che = ac->che[type][i]; |
1506 if(che) { | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1507 if(type <= TYPE_CPE) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1508 apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling); |
7581 | 1509 if(che->ch[0].tns.present) |
1510 apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1); | |
1511 if(che->ch[1].tns.present) | |
1512 apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1); | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1513 if(type <= TYPE_CPE) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1514 apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling); |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1515 if(type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1516 imdct_and_windowing(ac, &che->ch[0]); |
7581 | 1517 if(type == TYPE_CPE) |
1518 imdct_and_windowing(ac, &che->ch[1]); | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1519 if(type <= TYPE_CCE) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1520 apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling); |
7578 | 1521 } |
1522 } | |
1523 } | |
1524 } | |
1525 | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1526 static int parse_adts_frame_header(AACContext * ac, GetBitContext * gb) { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1527 |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1528 int size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1529 AACADTSHeaderInfo hdr_info; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1530 |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1531 size = ff_aac_parse_header(gb, &hdr_info); |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1532 if (size > 0) { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1533 if (hdr_info.chan_config) |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1534 ac->m4ac.chan_config = hdr_info.chan_config; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1535 ac->m4ac.sample_rate = hdr_info.sample_rate; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1536 ac->m4ac.sampling_index = hdr_info.sampling_index; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1537 ac->m4ac.object_type = hdr_info.object_type; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1538 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1539 if (hdr_info.num_aac_frames == 1) { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1540 if (!hdr_info.crc_absent) |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1541 skip_bits(gb, 16); |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1542 } else { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1543 ff_log_missing_feature(ac->avccontext, "More than one AAC RDB per ADTS frame is", 0); |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1544 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1545 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1546 return size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1547 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1548 |
7578 | 1549 static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data_size, const uint8_t * buf, int buf_size) { |
1550 AACContext * ac = avccontext->priv_data; | |
1551 GetBitContext gb; | |
1552 enum RawDataBlockType elem_type; | |
1553 int err, elem_id, data_size_tmp; | |
1554 | |
1555 init_get_bits(&gb, buf, buf_size*8); | |
1556 | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1557 if (show_bits(&gb, 12) == 0xfff) { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1558 if ((err = parse_adts_frame_header(ac, &gb)) < 0) { |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1559 av_log(avccontext, AV_LOG_ERROR, "Error decoding AAC frame header.\n"); |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1560 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1561 } |
8812 | 1562 if (ac->m4ac.sampling_index > 12) { |
8789 | 1563 av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); |
1564 return -1; | |
1565 } | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1566 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1567 |
7578 | 1568 // parse |
1569 while ((elem_type = get_bits(&gb, 3)) != TYPE_END) { | |
1570 elem_id = get_bits(&gb, 4); | |
1571 err = -1; | |
1572 | |
1573 if(elem_type == TYPE_SCE && elem_id == 1 && | |
1574 !ac->che[TYPE_SCE][elem_id] && ac->che[TYPE_LFE][0]) { | |
1575 /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1] | |
1576 instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have | |
1577 encountered such a stream, transfer the LFE[0] element to SCE[1] */ | |
1578 ac->che[TYPE_SCE][elem_id] = ac->che[TYPE_LFE][0]; | |
1579 ac->che[TYPE_LFE][0] = NULL; | |
1580 } | |
8814 | 1581 if(elem_type < TYPE_DSE && !ac->che[elem_type][elem_id]) { |
1582 av_log(ac->avccontext, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", elem_type, elem_id); | |
1583 return -1; | |
7578 | 1584 } |
1585 | |
1586 switch (elem_type) { | |
1587 | |
1588 case TYPE_SCE: | |
1589 err = decode_ics(ac, &ac->che[TYPE_SCE][elem_id]->ch[0], &gb, 0, 0); | |
1590 break; | |
1591 | |
1592 case TYPE_CPE: | |
1593 err = decode_cpe(ac, &gb, elem_id); | |
1594 break; | |
1595 | |
1596 case TYPE_CCE: | |
7733 | 1597 err = decode_cce(ac, &gb, ac->che[TYPE_CCE][elem_id]); |
7578 | 1598 break; |
1599 | |
1600 case TYPE_LFE: | |
1601 err = decode_ics(ac, &ac->che[TYPE_LFE][elem_id]->ch[0], &gb, 0, 0); | |
1602 break; | |
1603 | |
1604 case TYPE_DSE: | |
1605 skip_data_stream_element(&gb); | |
1606 err = 0; | |
1607 break; | |
1608 | |
1609 case TYPE_PCE: | |
1610 { | |
1611 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; | |
1612 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
1613 if((err = decode_pce(ac, new_che_pos, &gb))) | |
1614 break; | |
1615 err = output_configure(ac, ac->che_pos, new_che_pos); | |
1616 break; | |
1617 } | |
1618 | |
1619 case TYPE_FIL: | |
1620 if (elem_id == 15) | |
1621 elem_id += get_bits(&gb, 8) - 1; | |
1622 while (elem_id > 0) | |
1623 elem_id -= decode_extension_payload(ac, &gb, elem_id); | |
1624 err = 0; /* FIXME */ | |
1625 break; | |
1626 | |
1627 default: | |
1628 err = -1; /* should not happen, but keeps compiler happy */ | |
1629 break; | |
1630 } | |
1631 | |
1632 if(err) | |
1633 return err; | |
1634 } | |
1635 | |
1636 spectral_to_sample(ac); | |
1637 | |
7539 | 1638 if (!ac->is_saved) { |
1639 ac->is_saved = 1; | |
1640 *data_size = 0; | |
7580 | 1641 return buf_size; |
7539 | 1642 } |
1643 | |
1644 data_size_tmp = 1024 * avccontext->channels * sizeof(int16_t); | |
1645 if(*data_size < data_size_tmp) { | |
1646 av_log(avccontext, AV_LOG_ERROR, | |
1647 "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n", | |
1648 *data_size, data_size_tmp); | |
1649 return -1; | |
1650 } | |
1651 *data_size = data_size_tmp; | |
1652 | |
1653 ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, 1024, avccontext->channels); | |
1654 | |
1655 return buf_size; | |
1656 } | |
1657 | |
7501 | 1658 static av_cold int aac_decode_close(AVCodecContext * avccontext) { |
1659 AACContext * ac = avccontext->priv_data; | |
7540 | 1660 int i, type; |
7501 | 1661 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1662 for (i = 0; i < MAX_ELEM_ID; i++) { |
7540 | 1663 for(type = 0; type < 4; type++) |
1664 av_freep(&ac->che[type][i]); | |
7501 | 1665 } |
1666 | |
1667 ff_mdct_end(&ac->mdct); | |
1668 ff_mdct_end(&ac->mdct_small); | |
1669 return 0 ; | |
1670 } | |
1671 | |
1672 AVCodec aac_decoder = { | |
1673 "aac", | |
1674 CODEC_TYPE_AUDIO, | |
1675 CODEC_ID_AAC, | |
1676 sizeof(AACContext), | |
1677 aac_decode_init, | |
1678 NULL, | |
1679 aac_decode_close, | |
1680 aac_decode_frame, | |
1681 .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
|
1682 .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, |
7501 | 1683 }; |