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