Mercurial > libavcodec.hg
annotate aacdec.c @ 12483:0159a19bfff7 libavcodec
aacdec: Rework channel mapping compatibility hacks.
For a PCE based configuration map the channels solely based on tags.
For an indexed configuration map the channels solely based on position.
This works with all known exotic samples including al17, elem_id0, bad_concat,
and lfe_is_sce.
author | alexc |
---|---|
date | Fri, 10 Sep 2010 18:01:48 +0000 |
parents | 65619c2230e7 |
children |
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 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
24 * @file |
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 | |
11401 | 65 * Y Spectral Band Replication |
7501 | 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) | |
11886 | 70 * Y Parametric Stereo |
7501 | 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" |
11370 | 83 #include "fft.h" |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
84 #include "lpc.h" |
7501 | 85 |
86 #include "aac.h" | |
87 #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
|
88 #include "aacdectab.h" |
11489
1aba21918874
Allow hard-coding of the 32kB cubic-root table for AAC.
reimar
parents:
11481
diff
changeset
|
89 #include "cbrt_tablegen.h" |
11401 | 90 #include "sbr.h" |
91 #include "aacsbr.h" | |
7501 | 92 #include "mpeg4audio.h" |
12149
e7634f1b6100
Split the ADTS header decoder off of the ADTS parser.
alexc
parents:
12148
diff
changeset
|
93 #include "aacadtsdec.h" |
7501 | 94 |
95 #include <assert.h> | |
96 #include <errno.h> | |
97 #include <math.h> | |
98 #include <string.h> | |
99 | |
10881 | 100 #if ARCH_ARM |
101 # include "arm/aac.h" | |
102 #endif | |
103 | |
10004 | 104 union float754 { |
105 float f; | |
106 uint32_t i; | |
107 }; | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
108 |
7501 | 109 static VLC vlc_scalefactors; |
110 static VLC vlc_spectral[11]; | |
111 | |
11205 | 112 static const char overread_err[] = "Input buffer exhausted before END element found\n"; |
113 | |
10004 | 114 static ChannelElement *get_che(AACContext *ac, int type, int elem_id) |
115 { | |
12483
0159a19bfff7
aacdec: Rework channel mapping compatibility hacks.
alexc
parents:
12260
diff
changeset
|
116 // For PCE based channel configurations map the channels solely based on tags. |
0159a19bfff7
aacdec: Rework channel mapping compatibility hacks.
alexc
parents:
12260
diff
changeset
|
117 if (!ac->m4ac.chan_config) { |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
118 return ac->tag_che_map[type][elem_id]; |
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
119 } |
12483
0159a19bfff7
aacdec: Rework channel mapping compatibility hacks.
alexc
parents:
12260
diff
changeset
|
120 // For indexed channel configurations map the channels solely based on position. |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
121 switch (ac->m4ac.chan_config) { |
10004 | 122 case 7: |
123 if (ac->tags_mapped == 3 && type == TYPE_CPE) { | |
124 ac->tags_mapped++; | |
125 return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2]; | |
126 } | |
127 case 6: | |
128 /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1] | |
11787 | 129 instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have |
130 encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */ | |
10004 | 131 if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) { |
132 ac->tags_mapped++; | |
133 return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0]; | |
134 } | |
135 case 5: | |
136 if (ac->tags_mapped == 2 && type == TYPE_CPE) { | |
137 ac->tags_mapped++; | |
138 return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1]; | |
139 } | |
140 case 4: | |
141 if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) { | |
142 ac->tags_mapped++; | |
143 return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1]; | |
144 } | |
145 case 3: | |
146 case 2: | |
147 if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) { | |
148 ac->tags_mapped++; | |
149 return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0]; | |
150 } else if (ac->m4ac.chan_config == 2) { | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
151 return NULL; |
10004 | 152 } |
153 case 1: | |
154 if (!ac->tags_mapped && type == TYPE_SCE) { | |
155 ac->tags_mapped++; | |
156 return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0]; | |
157 } | |
158 default: | |
159 return NULL; | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
160 } |
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
161 } |
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
162 |
7539 | 163 /** |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
164 * Check for the channel element in the current channel position configuration. |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
165 * If it exists, make sure the appropriate element is allocated and map the |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
166 * channel order to match the internal FFmpeg channel layout. |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
167 * |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
168 * @param che_pos current channel position configuration |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
169 * @param type channel element type |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
170 * @param id channel element id |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
171 * @param channels count of the number of channels in the configuration |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
172 * |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
173 * @return Returns error status. 0 - OK, !0 - error |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
174 */ |
11177 | 175 static av_cold int che_configure(AACContext *ac, |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
176 enum ChannelPosition che_pos[4][MAX_ELEM_ID], |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
177 int type, int id, |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
178 int *channels) |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
179 { |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
180 if (che_pos[type][id]) { |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
181 if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement)))) |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
182 return AVERROR(ENOMEM); |
11401 | 183 ff_aac_sbr_ctx_init(&ac->che[type][id]->sbr); |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
184 if (type != TYPE_CCE) { |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
185 ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret; |
11886 | 186 if (type == TYPE_CPE || |
187 (type == TYPE_SCE && ac->m4ac.ps == 1)) { | |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
188 ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret; |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
189 } |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
190 } |
11401 | 191 } else { |
192 if (ac->che[type][id]) | |
193 ff_aac_sbr_ctx_close(&ac->che[type][id]->sbr); | |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
194 av_freep(&ac->che[type][id]); |
11401 | 195 } |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
196 return 0; |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
197 } |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
198 |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
199 /** |
7578 | 200 * Configure output channel order based on the current program configuration element. |
201 * | |
202 * @param che_pos current channel position configuration | |
203 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
204 * | |
205 * @return Returns error status. 0 - OK, !0 - error | |
206 */ | |
11176
490544c08c48
AAC: Mark functions that are only called when the output configuration is not locked as av_cold.
alexc
parents:
11119
diff
changeset
|
207 static av_cold int output_configure(AACContext *ac, |
10004 | 208 enum ChannelPosition che_pos[4][MAX_ELEM_ID], |
209 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], | |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
210 int channel_config, enum OCStatus oc_type) |
10004 | 211 { |
11833 | 212 AVCodecContext *avctx = ac->avctx; |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
213 int i, type, channels = 0, ret; |
7578 | 214 |
11886 | 215 if (new_che_pos != che_pos) |
7578 | 216 memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); |
217 | |
10306
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
218 if (channel_config) { |
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
219 for (i = 0; i < tags_per_config[channel_config]; i++) { |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
220 if ((ret = che_configure(ac, che_pos, |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
221 aac_channel_layout_map[channel_config - 1][i][0], |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
222 aac_channel_layout_map[channel_config - 1][i][1], |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
223 &channels))) |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
224 return ret; |
10306
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
225 } |
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
226 |
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
227 memset(ac->tag_che_map, 0, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0])); |
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
228 |
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
229 avctx->channel_layout = aac_channel_layout[channel_config - 1]; |
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
230 } else { |
10307 | 231 /* Allocate or free elements depending on if they are in the |
232 * current program configuration. | |
233 * | |
234 * Set up default 1:1 output mapping. | |
235 * | |
236 * For a 5.1 stream the output order will be: | |
237 * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ] | |
238 */ | |
7578 | 239 |
10307 | 240 for (i = 0; i < MAX_ELEM_ID; i++) { |
241 for (type = 0; type < 4; type++) { | |
10308
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
242 if ((ret = che_configure(ac, che_pos, type, i, &channels))) |
28b0f87cfdf1
Refactor channel element configuration and mapping code into its own function
superdump
parents:
10307
diff
changeset
|
243 return ret; |
10307 | 244 } |
7578 | 245 } |
246 | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
247 memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0])); |
10306
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
248 |
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
249 avctx->channel_layout = 0; |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
250 } |
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
251 |
7578 | 252 avctx->channels = channels; |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
253 |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
254 ac->output_configured = oc_type; |
9948
98fd723f72e7
Ignore subsequent channel configurations after the first in an AAC file. The
alexc
parents:
9891
diff
changeset
|
255 |
7578 | 256 return 0; |
257 } | |
258 | |
259 /** | |
7539 | 260 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit. |
261 * | |
262 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present. | |
263 * @param sce_map mono (Single Channel Element) map | |
264 * @param type speaker type/position for these channels | |
265 */ | |
266 static void decode_channel_map(enum ChannelPosition *cpe_map, | |
10004 | 267 enum ChannelPosition *sce_map, |
268 enum ChannelPosition type, | |
269 GetBitContext *gb, int n) | |
270 { | |
271 while (n--) { | |
7539 | 272 enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map |
273 map[get_bits(gb, 4)] = type; | |
274 } | |
275 } | |
276 | |
277 /** | |
278 * Decode program configuration element; reference: table 4.2. | |
279 * | |
280 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
281 * | |
282 * @return Returns error status. 0 - OK, !0 - error | |
283 */ | |
10004 | 284 static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], |
285 GetBitContext *gb) | |
286 { | |
8412
2d48043ab521
AAC: Don't write an illegal sampling_index in a PCE to the MPEG4AudioConfig
superdump
parents:
8286
diff
changeset
|
287 int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index; |
11205 | 288 int comment_len; |
7539 | 289 |
290 skip_bits(gb, 2); // object_type | |
291 | |
8412
2d48043ab521
AAC: Don't write an illegal sampling_index in a PCE to the MPEG4AudioConfig
superdump
parents:
8286
diff
changeset
|
292 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
|
293 if (ac->m4ac.sampling_index != sampling_index) |
11833 | 294 av_log(ac->avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n"); |
9716
d45e44454d13
In the event of a mismatch, do not follow the sample rate index in an AAC PCE.
alexc
parents:
9658
diff
changeset
|
295 |
7501 | 296 num_front = get_bits(gb, 4); |
297 num_side = get_bits(gb, 4); | |
298 num_back = get_bits(gb, 4); | |
299 num_lfe = get_bits(gb, 2); | |
300 num_assoc_data = get_bits(gb, 3); | |
301 num_cc = get_bits(gb, 4); | |
302 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
303 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
|
304 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
|
305 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
|
306 skip_bits(gb, 4); // stereo_mixdown_tag |
7501 | 307 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
308 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
|
309 skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround |
7501 | 310 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
311 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
|
312 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
|
313 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
|
314 decode_channel_map(NULL, new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE, gb, num_lfe ); |
7501 | 315 |
316 skip_bits_long(gb, 4 * num_assoc_data); | |
317 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
318 decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC, gb, num_cc ); |
7501 | 319 |
320 align_get_bits(gb); | |
321 | |
322 /* comment field, first byte is length */ | |
11205 | 323 comment_len = get_bits(gb, 8) * 8; |
324 if (get_bits_left(gb) < comment_len) { | |
11833 | 325 av_log(ac->avctx, AV_LOG_ERROR, overread_err); |
11205 | 326 return -1; |
327 } | |
328 skip_bits_long(gb, comment_len); | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
329 return 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
330 } |
7501 | 331 |
7539 | 332 /** |
333 * Set up channel positions based on a default channel configuration | |
334 * as specified in table 1.17. | |
335 * | |
336 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one. | |
337 * | |
338 * @return Returns error status. 0 - OK, !0 - error | |
339 */ | |
11176
490544c08c48
AAC: Mark functions that are only called when the output configuration is not locked as av_cold.
alexc
parents:
11119
diff
changeset
|
340 static av_cold int set_default_channel_config(AACContext *ac, |
10004 | 341 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], |
342 int channel_config) | |
7539 | 343 { |
10004 | 344 if (channel_config < 1 || channel_config > 7) { |
11833 | 345 av_log(ac->avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n", |
7539 | 346 channel_config); |
347 return -1; | |
348 } | |
349 | |
350 /* default channel configurations: | |
351 * | |
352 * 1ch : front center (mono) | |
353 * 2ch : L + R (stereo) | |
354 * 3ch : front center + L + R | |
355 * 4ch : front center + L + R + back center | |
356 * 5ch : front center + L + R + back stereo | |
357 * 6ch : front center + L + R + back stereo + LFE | |
358 * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE | |
359 */ | |
360 | |
10004 | 361 if (channel_config != 2) |
7539 | 362 new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono) |
10004 | 363 if (channel_config > 1) |
7539 | 364 new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo) |
10004 | 365 if (channel_config == 4) |
7539 | 366 new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK; // back center |
10004 | 367 if (channel_config > 4) |
7539 | 368 new_che_pos[TYPE_CPE][(channel_config == 7) + 1] |
10004 | 369 = AAC_CHANNEL_BACK; // back stereo |
370 if (channel_config > 5) | |
7539 | 371 new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE; // LFE |
10004 | 372 if (channel_config == 7) |
7539 | 373 new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right |
374 | |
375 return 0; | |
376 } | |
377 | |
7578 | 378 /** |
379 * Decode GA "General Audio" specific configuration; reference: table 4.1. | |
380 * | |
381 * @return Returns error status. 0 - OK, !0 - error | |
382 */ | |
10004 | 383 static int decode_ga_specific_config(AACContext *ac, GetBitContext *gb, |
384 int channel_config) | |
385 { | |
7578 | 386 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; |
387 int extension_flag, ret; | |
388 | |
10004 | 389 if (get_bits1(gb)) { // frameLengthFlag |
11833 | 390 av_log_missing_feature(ac->avctx, "960/120 MDCT window is", 1); |
7539 | 391 return -1; |
392 } | |
393 | |
394 if (get_bits1(gb)) // dependsOnCoreCoder | |
395 skip_bits(gb, 14); // coreCoderDelay | |
396 extension_flag = get_bits1(gb); | |
397 | |
10004 | 398 if (ac->m4ac.object_type == AOT_AAC_SCALABLE || |
399 ac->m4ac.object_type == AOT_ER_AAC_SCALABLE) | |
7539 | 400 skip_bits(gb, 3); // layerNr |
401 | |
402 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
403 if (channel_config == 0) { | |
404 skip_bits(gb, 4); // element_instance_tag | |
10004 | 405 if ((ret = decode_pce(ac, new_che_pos, gb))) |
7539 | 406 return ret; |
407 } else { | |
10004 | 408 if ((ret = set_default_channel_config(ac, new_che_pos, channel_config))) |
7539 | 409 return ret; |
410 } | |
10622
2474aceea736
AAC: Add a global header but output not locked output configuration status.
alexc
parents:
10621
diff
changeset
|
411 if ((ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR))) |
7539 | 412 return ret; |
413 | |
414 if (extension_flag) { | |
415 switch (ac->m4ac.object_type) { | |
10004 | 416 case AOT_ER_BSAC: |
417 skip_bits(gb, 5); // numOfSubFrame | |
418 skip_bits(gb, 11); // layer_length | |
419 break; | |
420 case AOT_ER_AAC_LC: | |
421 case AOT_ER_AAC_LTP: | |
422 case AOT_ER_AAC_SCALABLE: | |
423 case AOT_ER_AAC_LD: | |
424 skip_bits(gb, 3); /* aacSectionDataResilienceFlag | |
7539 | 425 * aacScalefactorDataResilienceFlag |
426 * aacSpectralDataResilienceFlag | |
427 */ | |
10004 | 428 break; |
7539 | 429 } |
430 skip_bits1(gb); // extensionFlag3 (TBD in version 3) | |
431 } | |
432 return 0; | |
433 } | |
434 | |
435 /** | |
436 * Decode audio specific configuration; reference: table 1.13. | |
437 * | |
438 * @param data pointer to AVCodecContext extradata | |
439 * @param data_size size of AVCCodecContext extradata | |
440 * | |
441 * @return Returns error status. 0 - OK, !0 - error | |
442 */ | |
10004 | 443 static int decode_audio_specific_config(AACContext *ac, void *data, |
444 int data_size) | |
445 { | |
7539 | 446 GetBitContext gb; |
447 int i; | |
448 | |
449 init_get_bits(&gb, data, data_size * 8); | |
450 | |
10004 | 451 if ((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0) |
7539 | 452 return -1; |
10004 | 453 if (ac->m4ac.sampling_index > 12) { |
11833 | 454 av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); |
7539 | 455 return -1; |
456 } | |
11886 | 457 if (ac->m4ac.sbr == 1 && ac->m4ac.ps == -1) |
458 ac->m4ac.ps = 1; | |
7539 | 459 |
460 skip_bits_long(&gb, i); | |
461 | |
462 switch (ac->m4ac.object_type) { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
463 case AOT_AAC_MAIN: |
7539 | 464 case AOT_AAC_LC: |
465 if (decode_ga_specific_config(ac, &gb, ac->m4ac.chan_config)) | |
466 return -1; | |
467 break; | |
468 default: | |
11833 | 469 av_log(ac->avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n", |
7539 | 470 ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type); |
471 return -1; | |
472 } | |
473 return 0; | |
474 } | |
475 | |
7578 | 476 /** |
477 * linear congruential pseudorandom number generator | |
478 * | |
479 * @param previous_val pointer to the current state of the generator | |
480 * | |
481 * @return Returns a 32-bit pseudorandom integer | |
482 */ | |
10004 | 483 static av_always_inline int lcg_random(int previous_val) |
484 { | |
7578 | 485 return previous_val * 1664525 + 1013904223; |
486 } | |
487 | |
11358 | 488 static av_always_inline void reset_predict_state(PredictorState *ps) |
10004 | 489 { |
490 ps->r0 = 0.0f; | |
491 ps->r1 = 0.0f; | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
492 ps->cor0 = 0.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
493 ps->cor1 = 0.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
494 ps->var0 = 1.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
495 ps->var1 = 1.0f; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
496 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
497 |
10004 | 498 static void reset_all_predictors(PredictorState *ps) |
499 { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
500 int i; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
501 for (i = 0; i < MAX_PREDICTORS; i++) |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
502 reset_predict_state(&ps[i]); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
503 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
504 |
10004 | 505 static void reset_predictor_group(PredictorState *ps, int group_num) |
506 { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
507 int i; |
10004 | 508 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
|
509 reset_predict_state(&ps[i]); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
510 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
511 |
11835
758c052eb8a9
aac: Move an initialization macro used only by the decoder out of the header.
alexc
parents:
11834
diff
changeset
|
512 #define AAC_INIT_VLC_STATIC(num, size) \ |
758c052eb8a9
aac: Move an initialization macro used only by the decoder out of the header.
alexc
parents:
11834
diff
changeset
|
513 INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num], \ |
758c052eb8a9
aac: Move an initialization macro used only by the decoder out of the header.
alexc
parents:
11834
diff
changeset
|
514 ff_aac_spectral_bits[num], sizeof( ff_aac_spectral_bits[num][0]), sizeof( ff_aac_spectral_bits[num][0]), \ |
758c052eb8a9
aac: Move an initialization macro used only by the decoder out of the header.
alexc
parents:
11834
diff
changeset
|
515 ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), sizeof(ff_aac_spectral_codes[num][0]), \ |
758c052eb8a9
aac: Move an initialization macro used only by the decoder out of the header.
alexc
parents:
11834
diff
changeset
|
516 size); |
758c052eb8a9
aac: Move an initialization macro used only by the decoder out of the header.
alexc
parents:
11834
diff
changeset
|
517 |
11833 | 518 static av_cold int aac_decode_init(AVCodecContext *avctx) |
10004 | 519 { |
11833 | 520 AACContext *ac = avctx->priv_data; |
7501 | 521 |
11833 | 522 ac->avctx = avctx; |
523 ac->m4ac.sample_rate = avctx->sample_rate; | |
7501 | 524 |
11833 | 525 if (avctx->extradata_size > 0) { |
526 if (decode_audio_specific_config(ac, avctx->extradata, avctx->extradata_size)) | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
527 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
528 } |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
529 |
11833 | 530 avctx->sample_fmt = SAMPLE_FMT_S16; |
7501 | 531 |
10877 | 532 AAC_INIT_VLC_STATIC( 0, 304); |
533 AAC_INIT_VLC_STATIC( 1, 270); | |
534 AAC_INIT_VLC_STATIC( 2, 550); | |
535 AAC_INIT_VLC_STATIC( 3, 300); | |
536 AAC_INIT_VLC_STATIC( 4, 328); | |
537 AAC_INIT_VLC_STATIC( 5, 294); | |
538 AAC_INIT_VLC_STATIC( 6, 306); | |
539 AAC_INIT_VLC_STATIC( 7, 268); | |
540 AAC_INIT_VLC_STATIC( 8, 510); | |
541 AAC_INIT_VLC_STATIC( 9, 366); | |
542 AAC_INIT_VLC_STATIC(10, 462); | |
7501 | 543 |
11401 | 544 ff_aac_sbr_init(); |
545 | |
11833 | 546 dsputil_init(&ac->dsp, avctx); |
7501 | 547 |
7539 | 548 ac->random_state = 0x1f2e3d4c; |
549 | |
7501 | 550 // -1024 - Compensate wrong IMDCT method. |
551 // 32768 - Required to scale values to the correct range for the bias method | |
552 // for float to int16 conversion. | |
553 | |
10377
98816e4d5522
dca and aac decoders use float_to_int16_interleave, so check for
conrad
parents:
10308
diff
changeset
|
554 if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) { |
10004 | 555 ac->add_bias = 385.0f; |
556 ac->sf_scale = 1. / (-1024. * 32768.); | |
7501 | 557 ac->sf_offset = 0; |
558 } else { | |
10004 | 559 ac->add_bias = 0.0f; |
560 ac->sf_scale = 1. / -1024.; | |
7501 | 561 ac->sf_offset = 60; |
562 } | |
563 | |
11932 | 564 ff_aac_tableinit(); |
7501 | 565 |
8042 | 566 INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code), |
10004 | 567 ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]), |
568 ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]), | |
569 352); | |
7501 | 570 |
9658
67a20f0eb42c
Support for getting (i)MDCT output multiplied by a constant scaling factor.
serge
parents:
9634
diff
changeset
|
571 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
|
572 ff_mdct_init(&ac->mdct_small, 8, 1, 1.0); |
7581 | 573 // window initialization |
574 ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024); | |
575 ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128); | |
10827
3d011a01a6a0
Add support for hard-coded MDCT-related ff_sine_windows tables.
reimar
parents:
10819
diff
changeset
|
576 ff_init_ff_sine_windows(10); |
3d011a01a6a0
Add support for hard-coded MDCT-related ff_sine_windows tables.
reimar
parents:
10819
diff
changeset
|
577 ff_init_ff_sine_windows( 7); |
7581 | 578 |
11489
1aba21918874
Allow hard-coding of the 32kB cubic-root table for AAC.
reimar
parents:
11481
diff
changeset
|
579 cbrt_tableinit(); |
10849 | 580 |
7501 | 581 return 0; |
582 } | |
583 | |
7539 | 584 /** |
585 * Skip data_stream_element; reference: table 4.10. | |
586 */ | |
11205 | 587 static int skip_data_stream_element(AACContext *ac, GetBitContext *gb) |
10004 | 588 { |
7501 | 589 int byte_align = get_bits1(gb); |
590 int count = get_bits(gb, 8); | |
591 if (count == 255) | |
592 count += get_bits(gb, 8); | |
593 if (byte_align) | |
594 align_get_bits(gb); | |
11205 | 595 |
596 if (get_bits_left(gb) < 8 * count) { | |
11833 | 597 av_log(ac->avctx, AV_LOG_ERROR, overread_err); |
11205 | 598 return -1; |
599 } | |
7501 | 600 skip_bits_long(gb, 8 * count); |
11205 | 601 return 0; |
7501 | 602 } |
603 | |
10004 | 604 static int decode_prediction(AACContext *ac, IndividualChannelStream *ics, |
605 GetBitContext *gb) | |
606 { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
607 int sfb; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
608 if (get_bits1(gb)) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
609 ics->predictor_reset_group = get_bits(gb, 5); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
610 if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) { |
11833 | 611 av_log(ac->avctx, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n"); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
612 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
613 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
614 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
615 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
|
616 ics->prediction_used[sfb] = get_bits1(gb); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
617 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
618 return 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
619 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
620 |
7501 | 621 /** |
7539 | 622 * Decode Individual Channel Stream info; reference: table 4.6. |
623 * | |
624 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
625 */ | |
10004 | 626 static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics, |
627 GetBitContext *gb, int common_window) | |
628 { | |
7539 | 629 if (get_bits1(gb)) { |
11833 | 630 av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n"); |
7539 | 631 memset(ics, 0, sizeof(IndividualChannelStream)); |
632 return -1; | |
633 } | |
634 ics->window_sequence[1] = ics->window_sequence[0]; | |
635 ics->window_sequence[0] = get_bits(gb, 2); | |
10004 | 636 ics->use_kb_window[1] = ics->use_kb_window[0]; |
637 ics->use_kb_window[0] = get_bits1(gb); | |
638 ics->num_window_groups = 1; | |
639 ics->group_len[0] = 1; | |
7581 | 640 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
641 int i; | |
642 ics->max_sfb = get_bits(gb, 4); | |
643 for (i = 0; i < 7; i++) { | |
644 if (get_bits1(gb)) { | |
10004 | 645 ics->group_len[ics->num_window_groups - 1]++; |
7581 | 646 } else { |
647 ics->num_window_groups++; | |
10004 | 648 ics->group_len[ics->num_window_groups - 1] = 1; |
7581 | 649 } |
650 } | |
10004 | 651 ics->num_windows = 8; |
652 ics->swb_offset = ff_swb_offset_128[ac->m4ac.sampling_index]; | |
653 ics->num_swb = ff_aac_num_swb_128[ac->m4ac.sampling_index]; | |
654 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
|
655 ics->predictor_present = 0; |
7581 | 656 } else { |
10004 | 657 ics->max_sfb = get_bits(gb, 6); |
658 ics->num_windows = 1; | |
659 ics->swb_offset = ff_swb_offset_1024[ac->m4ac.sampling_index]; | |
660 ics->num_swb = ff_aac_num_swb_1024[ac->m4ac.sampling_index]; | |
661 ics->tns_max_bands = ff_tns_max_bands_1024[ac->m4ac.sampling_index]; | |
662 ics->predictor_present = get_bits1(gb); | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
663 ics->predictor_reset_group = 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
664 if (ics->predictor_present) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
665 if (ac->m4ac.object_type == AOT_AAC_MAIN) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
666 if (decode_prediction(ac, ics, gb)) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
667 memset(ics, 0, sizeof(IndividualChannelStream)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
668 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
669 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
670 } else if (ac->m4ac.object_type == AOT_AAC_LC) { |
11833 | 671 av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n"); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
672 memset(ics, 0, sizeof(IndividualChannelStream)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
673 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
674 } else { |
11833 | 675 av_log_missing_feature(ac->avctx, "Predictor bit set but LTP is", 1); |
8200 | 676 memset(ics, 0, sizeof(IndividualChannelStream)); |
677 return -1; | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
678 } |
7578 | 679 } |
680 } | |
681 | |
10004 | 682 if (ics->max_sfb > ics->num_swb) { |
11833 | 683 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 684 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n", |
685 ics->max_sfb, ics->num_swb); | |
7578 | 686 memset(ics, 0, sizeof(IndividualChannelStream)); |
687 return -1; | |
688 } | |
689 | |
7539 | 690 return 0; |
691 } | |
692 | |
693 /** | |
694 * Decode band types (section_data payload); reference: table 4.46. | |
695 * | |
696 * @param band_type array of the used band type | |
697 * @param band_type_run_end array of the last scalefactor band of a band type run | |
698 * | |
699 * @return Returns error status. 0 - OK, !0 - error | |
700 */ | |
10004 | 701 static int decode_band_types(AACContext *ac, enum BandType band_type[120], |
702 int band_type_run_end[120], GetBitContext *gb, | |
703 IndividualChannelStream *ics) | |
704 { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
705 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
|
706 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
|
707 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
|
708 int k = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
709 while (k < ics->max_sfb) { |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
710 uint8_t sect_end = k; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
711 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
|
712 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
|
713 if (sect_band_type == 12) { |
11833 | 714 av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n"); |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
715 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
716 } |
10004 | 717 while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits) - 1) |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
718 sect_end += sect_len_incr; |
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
719 sect_end += sect_len_incr; |
11281
11fb96e94573
aac: Keep decode_band_types() from eating all padding at the end of a buffer.
alexc
parents:
11205
diff
changeset
|
720 if (get_bits_left(gb) < 0) { |
11833 | 721 av_log(ac->avctx, AV_LOG_ERROR, overread_err); |
11281
11fb96e94573
aac: Keep decode_band_types() from eating all padding at the end of a buffer.
alexc
parents:
11205
diff
changeset
|
722 return -1; |
11fb96e94573
aac: Keep decode_band_types() from eating all padding at the end of a buffer.
alexc
parents:
11205
diff
changeset
|
723 } |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
724 if (sect_end > ics->max_sfb) { |
11833 | 725 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 726 "Number of bands (%d) exceeds limit (%d).\n", |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
727 sect_end, 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
|
728 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
729 } |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
730 for (; k < sect_end; k++) { |
7581 | 731 band_type [idx] = sect_band_type; |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
732 band_type_run_end[idx++] = sect_end; |
7581 | 733 } |
7539 | 734 } |
735 } | |
736 return 0; | |
737 } | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
738 |
7539 | 739 /** |
740 * 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
|
741 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
742 * @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
|
743 * @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
|
744 * @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
|
745 * @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
|
746 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
747 * @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
|
748 */ |
10004 | 749 static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb, |
750 unsigned int global_gain, | |
751 IndividualChannelStream *ics, | |
752 enum BandType band_type[120], | |
753 int band_type_run_end[120]) | |
754 { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
755 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
|
756 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
|
757 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
|
758 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
|
759 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
|
760 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
|
761 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
|
762 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
|
763 if (band_type[idx] == ZERO_BT) { |
10004 | 764 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
|
765 sf[idx] = 0.; |
10004 | 766 } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) { |
767 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
|
768 offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
10004 | 769 if (offset[2] > 255U) { |
11833 | 770 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 771 "%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
|
772 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
773 } |
10004 | 774 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
|
775 } |
10004 | 776 } else if (band_type[idx] == NOISE_BT) { |
777 for (; i < run_end; i++, idx++) { | |
778 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
|
779 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
|
780 else |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
781 offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
10004 | 782 if (offset[1] > 255U) { |
11833 | 783 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 784 "%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
|
785 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
786 } |
10004 | 787 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
|
788 } |
10004 | 789 } else { |
790 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
|
791 offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
10004 | 792 if (offset[0] > 255U) { |
11833 | 793 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 794 "%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
|
795 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
796 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
797 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
|
798 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
799 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
800 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
801 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
802 return 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
803 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
804 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
805 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
806 * 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
|
807 */ |
10004 | 808 static int decode_pulses(Pulse *pulse, GetBitContext *gb, |
809 const uint16_t *swb_offset, int num_swb) | |
810 { | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
811 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
|
812 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
|
813 pulse_swb = get_bits(gb, 6); |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
814 if (pulse_swb >= num_swb) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
815 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
816 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
|
817 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
|
818 if (pulse->pos[0] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
819 return -1; |
7580 | 820 pulse->amp[0] = get_bits(gb, 4); |
821 for (i = 1; i < pulse->num_pulse; i++) { | |
10004 | 822 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
|
823 if (pulse->pos[i] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
824 return -1; |
7580 | 825 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
|
826 } |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
827 return 0; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
828 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
829 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
830 /** |
7609 | 831 * Decode Temporal Noise Shaping data; reference: table 4.48. |
832 * | |
833 * @return Returns error status. 0 - OK, !0 - error | |
834 */ | |
10004 | 835 static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns, |
836 GetBitContext *gb, const IndividualChannelStream *ics) | |
837 { | |
7609 | 838 int w, filt, i, coef_len, coef_res, coef_compress; |
839 const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE; | |
840 const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12; | |
841 for (w = 0; w < ics->num_windows; w++) { | |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
842 if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) { |
7609 | 843 coef_res = get_bits1(gb); |
844 | |
7638 | 845 for (filt = 0; filt < tns->n_filt[w]; filt++) { |
846 int tmp2_idx; | |
10004 | 847 tns->length[w][filt] = get_bits(gb, 6 - 2 * is8); |
7609 | 848 |
10004 | 849 if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) { |
11833 | 850 av_log(ac->avctx, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n", |
7638 | 851 tns->order[w][filt], tns_max_order); |
852 tns->order[w][filt] = 0; | |
853 return -1; | |
854 } | |
7850
77030651ddd0
Only read some of TNS bitstream data in the case that the TNS filter order is
superdump
parents:
7845
diff
changeset
|
855 if (tns->order[w][filt]) { |
7851 | 856 tns->direction[w][filt] = get_bits1(gb); |
857 coef_compress = get_bits1(gb); | |
858 coef_len = coef_res + 3 - coef_compress; | |
10004 | 859 tmp2_idx = 2 * coef_compress + coef_res; |
7638 | 860 |
7851 | 861 for (i = 0; i < tns->order[w][filt]; i++) |
862 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
|
863 } |
7609 | 864 } |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
865 } |
7609 | 866 } |
867 return 0; | |
868 } | |
869 | |
870 /** | |
7539 | 871 * Decode Mid/Side data; reference: table 4.54. |
872 * | |
873 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
874 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
875 * [3] reserved for scalable AAC | |
876 */ | |
10004 | 877 static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb, |
878 int ms_present) | |
879 { | |
7578 | 880 int idx; |
881 if (ms_present == 1) { | |
882 for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++) | |
883 cpe->ms_mask[idx] = get_bits1(gb); | |
884 } else if (ms_present == 2) { | |
885 memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0])); | |
886 } | |
887 } | |
7539 | 888 |
10881 | 889 #ifndef VMUL2 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
890 static inline float *VMUL2(float *dst, const float *v, unsigned idx, |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
891 const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
892 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
893 float s = *scale; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
894 *dst++ = v[idx & 15] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
895 *dst++ = v[idx>>4 & 15] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
896 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
897 } |
10881 | 898 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
899 |
10881 | 900 #ifndef VMUL4 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
901 static inline float *VMUL4(float *dst, const float *v, unsigned idx, |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
902 const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
903 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
904 float s = *scale; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
905 *dst++ = v[idx & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
906 *dst++ = v[idx>>2 & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
907 *dst++ = v[idx>>4 & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
908 *dst++ = v[idx>>6 & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
909 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
910 } |
10881 | 911 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
912 |
10881 | 913 #ifndef VMUL2S |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
914 static inline float *VMUL2S(float *dst, const float *v, unsigned idx, |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
915 unsigned sign, const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
916 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
917 union float754 s0, s1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
918 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
919 s0.f = s1.f = *scale; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
920 s0.i ^= sign >> 1 << 31; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
921 s1.i ^= sign << 31; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
922 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
923 *dst++ = v[idx & 15] * s0.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
924 *dst++ = v[idx>>4 & 15] * s1.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
925 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
926 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
927 } |
10881 | 928 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
929 |
10881 | 930 #ifndef VMUL4S |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
931 static inline float *VMUL4S(float *dst, const float *v, unsigned idx, |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
932 unsigned sign, const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
933 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
934 unsigned nz = idx >> 12; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
935 union float754 s = { .f = *scale }; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
936 union float754 t; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
937 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
938 t.i = s.i ^ (sign & 1<<31); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
939 *dst++ = v[idx & 3] * t.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
940 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
941 sign <<= nz & 1; nz >>= 1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
942 t.i = s.i ^ (sign & 1<<31); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
943 *dst++ = v[idx>>2 & 3] * t.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
944 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
945 sign <<= nz & 1; nz >>= 1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
946 t.i = s.i ^ (sign & 1<<31); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
947 *dst++ = v[idx>>4 & 3] * t.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
948 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
949 sign <<= nz & 1; nz >>= 1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
950 t.i = s.i ^ (sign & 1<<31); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
951 *dst++ = v[idx>>6 & 3] * t.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
952 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
953 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
954 } |
10881 | 955 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
956 |
7539 | 957 /** |
7581 | 958 * Decode spectral data; reference: table 4.50. |
959 * Dequantize and scale spectral data; reference: 4.6.3.3. | |
960 * | |
961 * @param coef array of dequantized, scaled spectral data | |
962 * @param sf array of scalefactors or intensity stereo positions | |
963 * @param pulse_present set if pulses are present | |
964 * @param pulse pointer to pulse data struct | |
965 * @param band_type array of the used band type | |
966 * | |
967 * @return Returns error status. 0 - OK, !0 - error | |
968 */ | |
10004 | 969 static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024], |
10819
dc84199b3306
AAC: add a const to decode_spectrum_and_dequant() args
mru
parents:
10688
diff
changeset
|
970 GetBitContext *gb, const float sf[120], |
10004 | 971 int pulse_present, const Pulse *pulse, |
972 const IndividualChannelStream *ics, | |
973 enum BandType band_type[120]) | |
974 { | |
7581 | 975 int i, k, g, idx = 0; |
10004 | 976 const int c = 1024 / ics->num_windows; |
977 const uint16_t *offsets = ics->swb_offset; | |
7581 | 978 float *coef_base = coef; |
979 | |
980 for (g = 0; g < ics->num_windows; g++) | |
10004 | 981 memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb])); |
7581 | 982 |
983 for (g = 0; g < ics->num_window_groups; g++) { | |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
984 unsigned g_len = ics->group_len[g]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
985 |
7581 | 986 for (i = 0; i < ics->max_sfb; i++, idx++) { |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
987 const unsigned cbt_m1 = band_type[idx] - 1; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
988 float *cfo = coef + offsets[i]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
989 int off_len = offsets[i + 1] - offsets[i]; |
7581 | 990 int group; |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
991 |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
992 if (cbt_m1 >= INTENSITY_BT2 - 1) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
993 for (group = 0; group < g_len; group++, cfo+=128) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
994 memset(cfo, 0, off_len * sizeof(float)); |
7581 | 995 } |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
996 } else if (cbt_m1 == NOISE_BT - 1) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
997 for (group = 0; group < g_len; group++, cfo+=128) { |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
998 float scale; |
10252 | 999 float band_energy; |
10220 | 1000 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1001 for (k = 0; k < off_len; k++) { |
7581 | 1002 ac->random_state = lcg_random(ac->random_state); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1003 cfo[k] = ac->random_state; |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
1004 } |
10220 | 1005 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1006 band_energy = ac->dsp.scalarproduct_float(cfo, cfo, off_len); |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
1007 scale = sf[idx] / sqrtf(band_energy); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1008 ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len); |
7581 | 1009 } |
10004 | 1010 } else { |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1011 const float *vq = ff_aac_codebook_vector_vals[cbt_m1]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1012 const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1013 VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1014 OPEN_READER(re, gb); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1015 |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1016 switch (cbt_m1 >> 1) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1017 case 0: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1018 for (group = 0; group < g_len; group++, cfo+=128) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1019 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1020 int len = off_len; |
10220 | 1021 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1022 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1023 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1024 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1025 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1026 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1027 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1028 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1029 cf = VMUL4(cf, vq, cb_idx, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1030 } while (len -= 4); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1031 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1032 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1033 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1034 case 1: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1035 for (group = 0; group < g_len; group++, cfo+=128) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1036 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1037 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1038 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1039 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1040 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1041 unsigned nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1042 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1043 uint32_t bits; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1044 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1045 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1046 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1047 #if MIN_CACHE_BITS < 20 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1048 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1049 #endif |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1050 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1051 nnz = cb_idx >> 8 & 15; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1052 bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1053 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1054 cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1055 } while (len -= 4); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1056 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1057 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1058 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1059 case 2: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1060 for (group = 0; group < g_len; group++, cfo+=128) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1061 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1062 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1063 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1064 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1065 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1066 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1067 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1068 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1069 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1070 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1071 cf = VMUL2(cf, vq, cb_idx, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1072 } while (len -= 2); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1073 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1074 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1075 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1076 case 3: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1077 case 4: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1078 for (group = 0; group < g_len; group++, cfo+=128) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1079 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1080 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1081 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1082 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1083 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1084 unsigned nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1085 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1086 unsigned sign; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1087 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1088 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1089 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1090 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1091 nnz = cb_idx >> 8 & 15; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1092 sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1093 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1094 cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1095 } while (len -= 2); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1096 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1097 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1098 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1099 default: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1100 for (group = 0; group < g_len; group++, cfo+=128) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1101 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1102 uint32_t *icf = (uint32_t *) cf; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1103 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1104 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1105 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1106 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1107 unsigned nzt, nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1108 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1109 uint32_t bits; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1110 int j; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1111 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1112 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1113 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1114 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1115 if (!code) { |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1116 *icf++ = 0; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1117 *icf++ = 0; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1118 continue; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1119 } |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1120 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1121 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1122 nnz = cb_idx >> 12; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1123 nzt = cb_idx >> 8; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1124 bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1125 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1126 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1127 for (j = 0; j < 2; j++) { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1128 if (nzt & 1<<j) { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1129 uint32_t b; |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1130 int n; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1131 /* The total length of escape_sequence must be < 22 bits according |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1132 to the specification (i.e. max is 111111110xxxxxxxxxxxx). */ |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1133 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1134 b = GET_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1135 b = 31 - av_log2(~b); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1136 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1137 if (b > 8) { |
11833 | 1138 av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n"); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1139 return -1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1140 } |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1141 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1142 #if MIN_CACHE_BITS < 21 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1143 LAST_SKIP_BITS(re, gb, b + 1); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1144 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1145 #else |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1146 SKIP_BITS(re, gb, b + 1); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1147 #endif |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1148 b += 4; |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1149 n = (1 << b) + SHOW_UBITS(re, gb, b); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1150 LAST_SKIP_BITS(re, gb, b); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1151 *icf++ = cbrt_tab[n] | (bits & 1<<31); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1152 bits <<= 1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1153 } else { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1154 unsigned v = ((const uint32_t*)vq)[cb_idx & 15]; |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1155 *icf++ = (bits & 1<<31) | v; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1156 bits <<= !!v; |
9053 | 1157 } |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1158 cb_idx >>= 4; |
9052
54973ad4b7cf
Refactor AAC unsigned band type decoding for a modest speedup.
alexc
parents:
9051
diff
changeset
|
1159 } |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1160 } while (len -= 2); |
10220 | 1161 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1162 ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len); |
7581 | 1163 } |
1164 } | |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1165 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1166 CLOSE_READER(re, gb); |
7581 | 1167 } |
1168 } | |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1169 coef += g_len << 7; |
7581 | 1170 } |
1171 | |
1172 if (pulse_present) { | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1173 idx = 0; |
10004 | 1174 for (i = 0; i < pulse->num_pulse; i++) { |
1175 float co = coef_base[ pulse->pos[i] ]; | |
1176 while (offsets[idx + 1] <= pulse->pos[i]) | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1177 idx++; |
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1178 if (band_type[idx] != NOISE_BT && sf[idx]) { |
7858 | 1179 float ico = -pulse->amp[i]; |
1180 if (co) { | |
1181 co /= sf[idx]; | |
1182 ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico); | |
1183 } | |
1184 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
|
1185 } |
7581 | 1186 } |
1187 } | |
1188 return 0; | |
1189 } | |
1190 | |
10004 | 1191 static av_always_inline float flt16_round(float pf) |
1192 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1193 union float754 tmp; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1194 tmp.f = pf; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1195 tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1196 return tmp.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1197 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1198 |
10004 | 1199 static av_always_inline float flt16_even(float pf) |
1200 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1201 union float754 tmp; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1202 tmp.f = pf; |
10004 | 1203 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
|
1204 return tmp.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1205 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1206 |
10004 | 1207 static av_always_inline float flt16_trunc(float pf) |
1208 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1209 union float754 pun; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1210 pun.f = pf; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1211 pun.i &= 0xFFFF0000U; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1212 return pun.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1213 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1214 |
12259 | 1215 static av_always_inline void predict(PredictorState *ps, float *coef, |
1216 float sf_scale, float inv_sf_scale, | |
10004 | 1217 int output_enable) |
1218 { | |
1219 const float a = 0.953125; // 61.0 / 64 | |
1220 const float alpha = 0.90625; // 29.0 / 32 | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1221 float e0, e1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1222 float pv; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1223 float k1, k2; |
12260
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1224 float r0 = ps->r0, r1 = ps->r1; |
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1225 float cor0 = ps->cor0, cor1 = ps->cor1; |
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1226 float var0 = ps->var0, var1 = ps->var1; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1227 |
12260
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1228 k1 = var0 > 1 ? cor0 * flt16_even(a / var0) : 0; |
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1229 k2 = var1 > 1 ? cor1 * flt16_even(a / var1) : 0; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1230 |
12260
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1231 pv = flt16_round(k1 * r0 + k2 * r1); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1232 if (output_enable) |
12259 | 1233 *coef += pv * sf_scale; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1234 |
12259 | 1235 e0 = *coef * inv_sf_scale; |
12260
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1236 e1 = e0 - k1 * r0; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1237 |
12260
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1238 ps->cor1 = flt16_trunc(alpha * cor1 + r1 * e1); |
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1239 ps->var1 = flt16_trunc(alpha * var1 + 0.5f * (r1 * r1 + e1 * e1)); |
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1240 ps->cor0 = flt16_trunc(alpha * cor0 + r0 * e0); |
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1241 ps->var0 = flt16_trunc(alpha * var0 + 0.5f * (r0 * r0 + e0 * e0)); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1242 |
12260
65619c2230e7
aacdec: Only load and write each predictor variable one.
alexc
parents:
12259
diff
changeset
|
1243 ps->r1 = flt16_trunc(a * (r0 - k1 * e0)); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1244 ps->r0 = flt16_trunc(a * e0); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1245 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1246 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1247 /** |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1248 * Apply AAC-Main style frequency domain prediction. |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1249 */ |
10004 | 1250 static void apply_prediction(AACContext *ac, SingleChannelElement *sce) |
1251 { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1252 int sfb, k; |
12259 | 1253 float sf_scale = ac->sf_scale, inv_sf_scale = 1 / ac->sf_scale; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1254 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1255 if (!sce->ics.predictor_initialized) { |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1256 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1257 sce->ics.predictor_initialized = 1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1258 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1259 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1260 if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1261 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
|
1262 for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) { |
12259 | 1263 predict(&sce->predictor_state[k], &sce->coeffs[k], |
1264 sf_scale, inv_sf_scale, | |
10004 | 1265 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
|
1266 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1267 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1268 if (sce->ics.predictor_reset_group) |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1269 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
|
1270 } else |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1271 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1272 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1273 |
7581 | 1274 /** |
7539 | 1275 * Decode an individual_channel_stream payload; reference: table 4.44. |
1276 * | |
1277 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
1278 * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.) | |
1279 * | |
1280 * @return Returns error status. 0 - OK, !0 - error | |
1281 */ | |
10004 | 1282 static int decode_ics(AACContext *ac, SingleChannelElement *sce, |
1283 GetBitContext *gb, int common_window, int scale_flag) | |
1284 { | |
7539 | 1285 Pulse pulse; |
10004 | 1286 TemporalNoiseShaping *tns = &sce->tns; |
1287 IndividualChannelStream *ics = &sce->ics; | |
1288 float *out = sce->coeffs; | |
7539 | 1289 int global_gain, pulse_present = 0; |
1290 | |
7580 | 1291 /* This assignment is to silence a GCC warning about the variable being used |
1292 * uninitialized when in fact it always is. | |
7539 | 1293 */ |
1294 pulse.num_pulse = 0; | |
1295 | |
1296 global_gain = get_bits(gb, 8); | |
1297 | |
1298 if (!common_window && !scale_flag) { | |
1299 if (decode_ics_info(ac, ics, gb, 0) < 0) | |
1300 return -1; | |
1301 } | |
1302 | |
1303 if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0) | |
1304 return -1; | |
1305 if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0) | |
1306 return -1; | |
1307 | |
1308 pulse_present = 0; | |
1309 if (!scale_flag) { | |
1310 if ((pulse_present = get_bits1(gb))) { | |
1311 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { | |
11833 | 1312 av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n"); |
7539 | 1313 return -1; |
1314 } | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
1315 if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) { |
11833 | 1316 av_log(ac->avctx, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n"); |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
1317 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
1318 } |
7539 | 1319 } |
1320 if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics)) | |
1321 return -1; | |
1322 if (get_bits1(gb)) { | |
11833 | 1323 av_log_missing_feature(ac->avctx, "SSR", 1); |
7539 | 1324 return -1; |
1325 } | |
1326 } | |
1327 | |
7580 | 1328 if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0) |
7539 | 1329 return -1; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1330 |
10004 | 1331 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
|
1332 apply_prediction(ac, sce); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1333 |
7539 | 1334 return 0; |
1335 } | |
1336 | |
1337 /** | |
7581 | 1338 * Mid/Side stereo decoding; reference: 4.6.8.1.3. |
1339 */ | |
10220 | 1340 static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe) |
10004 | 1341 { |
1342 const IndividualChannelStream *ics = &cpe->ch[0].ics; | |
7581 | 1343 float *ch0 = cpe->ch[0].coeffs; |
1344 float *ch1 = cpe->ch[1].coeffs; | |
10220 | 1345 int g, i, group, idx = 0; |
10004 | 1346 const uint16_t *offsets = ics->swb_offset; |
7581 | 1347 for (g = 0; g < ics->num_window_groups; g++) { |
1348 for (i = 0; i < ics->max_sfb; i++, idx++) { | |
1349 if (cpe->ms_mask[idx] && | |
10004 | 1350 cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) { |
7581 | 1351 for (group = 0; group < ics->group_len[g]; group++) { |
10220 | 1352 ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i], |
1353 ch1 + group * 128 + offsets[i], | |
1354 offsets[i+1] - offsets[i]); | |
7581 | 1355 } |
1356 } | |
1357 } | |
10004 | 1358 ch0 += ics->group_len[g] * 128; |
1359 ch1 += ics->group_len[g] * 128; | |
7581 | 1360 } |
1361 } | |
1362 | |
1363 /** | |
1364 * intensity stereo decoding; reference: 4.6.8.2.3 | |
1365 * | |
1366 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
1367 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
1368 * [3] reserved for scalable AAC | |
1369 */ | |
10004 | 1370 static void apply_intensity_stereo(ChannelElement *cpe, int ms_present) |
1371 { | |
1372 const IndividualChannelStream *ics = &cpe->ch[1].ics; | |
1373 SingleChannelElement *sce1 = &cpe->ch[1]; | |
7581 | 1374 float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs; |
10004 | 1375 const uint16_t *offsets = ics->swb_offset; |
7581 | 1376 int g, group, i, k, idx = 0; |
1377 int c; | |
1378 float scale; | |
1379 for (g = 0; g < ics->num_window_groups; g++) { | |
1380 for (i = 0; i < ics->max_sfb;) { | |
1381 if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) { | |
1382 const int bt_run_end = sce1->band_type_run_end[idx]; | |
1383 for (; i < bt_run_end; i++, idx++) { | |
1384 c = -1 + 2 * (sce1->band_type[idx] - 14); | |
1385 if (ms_present) | |
1386 c *= 1 - 2 * cpe->ms_mask[idx]; | |
1387 scale = c * sce1->sf[idx]; | |
1388 for (group = 0; group < ics->group_len[g]; group++) | |
10004 | 1389 for (k = offsets[i]; k < offsets[i + 1]; k++) |
1390 coef1[group * 128 + k] = scale * coef0[group * 128 + k]; | |
7581 | 1391 } |
1392 } else { | |
1393 int bt_run_end = sce1->band_type_run_end[idx]; | |
1394 idx += bt_run_end - i; | |
1395 i = bt_run_end; | |
1396 } | |
1397 } | |
10004 | 1398 coef0 += ics->group_len[g] * 128; |
1399 coef1 += ics->group_len[g] * 128; | |
7581 | 1400 } |
1401 } | |
1402 | |
1403 /** | |
7539 | 1404 * Decode a channel_pair_element; reference: table 4.4. |
1405 * | |
1406 * @return Returns error status. 0 - OK, !0 - error | |
1407 */ | |
10004 | 1408 static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe) |
1409 { | |
7539 | 1410 int i, ret, common_window, ms_present = 0; |
1411 | |
1412 common_window = get_bits1(gb); | |
1413 if (common_window) { | |
1414 if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1)) | |
1415 return -1; | |
1416 i = cpe->ch[1].ics.use_kb_window[0]; | |
1417 cpe->ch[1].ics = cpe->ch[0].ics; | |
1418 cpe->ch[1].ics.use_kb_window[1] = i; | |
1419 ms_present = get_bits(gb, 2); | |
10004 | 1420 if (ms_present == 3) { |
11833 | 1421 av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n"); |
7539 | 1422 return -1; |
10004 | 1423 } else if (ms_present) |
7539 | 1424 decode_mid_side_stereo(cpe, gb, ms_present); |
1425 } | |
1426 if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0))) | |
1427 return ret; | |
1428 if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0))) | |
1429 return ret; | |
1430 | |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1431 if (common_window) { |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1432 if (ms_present) |
10220 | 1433 apply_mid_side_stereo(ac, cpe); |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1434 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
|
1435 apply_prediction(ac, &cpe->ch[0]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1436 apply_prediction(ac, &cpe->ch[1]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1437 } |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1438 } |
7539 | 1439 |
7580 | 1440 apply_intensity_stereo(cpe, ms_present); |
7539 | 1441 return 0; |
1442 } | |
1443 | |
12153 | 1444 static const float cce_scale[] = { |
1445 1.09050773266525765921, //2^(1/8) | |
1446 1.18920711500272106672, //2^(1/4) | |
1447 M_SQRT2, | |
1448 2, | |
1449 }; | |
1450 | |
7581 | 1451 /** |
1452 * Decode coupling_channel_element; reference: table 4.8. | |
1453 * | |
1454 * @return Returns error status. 0 - OK, !0 - error | |
1455 */ | |
10004 | 1456 static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che) |
1457 { | |
7581 | 1458 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
|
1459 int c, g, sfb, ret; |
7581 | 1460 int sign; |
1461 float scale; | |
10004 | 1462 SingleChannelElement *sce = &che->ch[0]; |
1463 ChannelCoupling *coup = &che->coup; | |
7581 | 1464 |
10004 | 1465 coup->coupling_point = 2 * get_bits1(gb); |
7578 | 1466 coup->num_coupled = get_bits(gb, 3); |
1467 for (c = 0; c <= coup->num_coupled; c++) { | |
1468 num_gain++; | |
1469 coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE; | |
1470 coup->id_select[c] = get_bits(gb, 4); | |
1471 if (coup->type[c] == TYPE_CPE) { | |
1472 coup->ch_select[c] = get_bits(gb, 2); | |
1473 if (coup->ch_select[c] == 3) | |
1474 num_gain++; | |
1475 } else | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1476 coup->ch_select[c] = 2; |
7578 | 1477 } |
10004 | 1478 coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1); |
7578 | 1479 |
10004 | 1480 sign = get_bits(gb, 1); |
12153 | 1481 scale = cce_scale[get_bits(gb, 2)]; |
7578 | 1482 |
1483 if ((ret = decode_ics(ac, sce, gb, 0, 0))) | |
1484 return ret; | |
1485 | |
1486 for (c = 0; c < num_gain; c++) { | |
10004 | 1487 int idx = 0; |
1488 int cge = 1; | |
7578 | 1489 int gain = 0; |
1490 float gain_cache = 1.; | |
1491 if (c) { | |
1492 cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb); | |
1493 gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0; | |
12154
8a50de6cf3f1
aacdec: Eliminate the use of doubles in decode_cce().
alexc
parents:
12153
diff
changeset
|
1494 gain_cache = powf(scale, -gain); |
7578 | 1495 } |
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
|
1496 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
|
1497 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
|
1498 } else { |
8823 | 1499 for (g = 0; g < sce->ics.num_window_groups; g++) { |
1500 for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) { | |
1501 if (sce->band_type[idx] != ZERO_BT) { | |
1502 if (!cge) { | |
1503 int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; | |
10004 | 1504 if (t) { |
8823 | 1505 int s = 1; |
1506 t = gain += t; | |
1507 if (sign) { | |
1508 s -= 2 * (t & 0x1); | |
1509 t >>= 1; | |
1510 } | |
12154
8a50de6cf3f1
aacdec: Eliminate the use of doubles in decode_cce().
alexc
parents:
12153
diff
changeset
|
1511 gain_cache = powf(scale, -t) * s; |
7578 | 1512 } |
1513 } | |
8823 | 1514 coup->gain[c][idx] = gain_cache; |
7578 | 1515 } |
1516 } | |
7890 | 1517 } |
1518 } | |
7578 | 1519 } |
1520 return 0; | |
1521 } | |
1522 | |
7539 | 1523 /** |
7578 | 1524 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53. |
1525 * | |
1526 * @return Returns number of bytes consumed. | |
1527 */ | |
10004 | 1528 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, |
1529 GetBitContext *gb) | |
1530 { | |
7578 | 1531 int i; |
1532 int num_excl_chan = 0; | |
1533 | |
1534 do { | |
1535 for (i = 0; i < 7; i++) | |
1536 che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb); | |
1537 } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb)); | |
1538 | |
1539 return num_excl_chan / 7; | |
1540 } | |
1541 | |
1542 /** | |
7539 | 1543 * Decode dynamic range information; reference: table 4.52. |
1544 * | |
1545 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1546 * | |
1547 * @return Returns number of bytes consumed. | |
1548 */ | |
10004 | 1549 static int decode_dynamic_range(DynamicRangeControl *che_drc, |
1550 GetBitContext *gb, int cnt) | |
1551 { | |
1552 int n = 1; | |
7539 | 1553 int drc_num_bands = 1; |
1554 int i; | |
1555 | |
1556 /* pce_tag_present? */ | |
10004 | 1557 if (get_bits1(gb)) { |
7539 | 1558 che_drc->pce_instance_tag = get_bits(gb, 4); |
1559 skip_bits(gb, 4); // tag_reserved_bits | |
1560 n++; | |
1561 } | |
1562 | |
1563 /* excluded_chns_present? */ | |
10004 | 1564 if (get_bits1(gb)) { |
7539 | 1565 n += decode_drc_channel_exclusions(che_drc, gb); |
1566 } | |
1567 | |
1568 /* drc_bands_present? */ | |
1569 if (get_bits1(gb)) { | |
1570 che_drc->band_incr = get_bits(gb, 4); | |
1571 che_drc->interpolation_scheme = get_bits(gb, 4); | |
1572 n++; | |
1573 drc_num_bands += che_drc->band_incr; | |
1574 for (i = 0; i < drc_num_bands; i++) { | |
1575 che_drc->band_top[i] = get_bits(gb, 8); | |
1576 n++; | |
1577 } | |
1578 } | |
1579 | |
1580 /* prog_ref_level_present? */ | |
1581 if (get_bits1(gb)) { | |
1582 che_drc->prog_ref_level = get_bits(gb, 7); | |
1583 skip_bits1(gb); // prog_ref_level_reserved_bits | |
1584 n++; | |
1585 } | |
1586 | |
1587 for (i = 0; i < drc_num_bands; i++) { | |
1588 che_drc->dyn_rng_sgn[i] = get_bits1(gb); | |
1589 che_drc->dyn_rng_ctl[i] = get_bits(gb, 7); | |
1590 n++; | |
1591 } | |
1592 | |
1593 return n; | |
1594 } | |
1595 | |
1596 /** | |
1597 * Decode extension data (incomplete); reference: table 4.51. | |
1598 * | |
1599 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1600 * | |
1601 * @return Returns number of bytes consumed | |
1602 */ | |
11401 | 1603 static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt, |
1604 ChannelElement *che, enum RawDataBlockType elem_type) | |
10004 | 1605 { |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1606 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
|
1607 int res = cnt; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1608 switch (get_bits(gb, 4)) { // extension type |
10004 | 1609 case EXT_SBR_DATA_CRC: |
1610 crc_flag++; | |
1611 case EXT_SBR_DATA: | |
11401 | 1612 if (!che) { |
11833 | 1613 av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n"); |
11401 | 1614 return res; |
1615 } else if (!ac->m4ac.sbr) { | |
11833 | 1616 av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n"); |
11401 | 1617 skip_bits_long(gb, 8 * cnt - 4); |
1618 return res; | |
1619 } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) { | |
11833 | 1620 av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n"); |
11401 | 1621 skip_bits_long(gb, 8 * cnt - 4); |
1622 return res; | |
11886 | 1623 } else if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) { |
1624 ac->m4ac.sbr = 1; | |
1625 ac->m4ac.ps = 1; | |
1626 output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured); | |
11401 | 1627 } else { |
1628 ac->m4ac.sbr = 1; | |
1629 } | |
1630 res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type); | |
10004 | 1631 break; |
1632 case EXT_DYNAMIC_RANGE: | |
1633 res = decode_dynamic_range(&ac->che_drc, gb, cnt); | |
1634 break; | |
1635 case EXT_FILL: | |
1636 case EXT_FILL_DATA: | |
1637 case EXT_DATA_ELEMENT: | |
1638 default: | |
1639 skip_bits_long(gb, 8 * cnt - 4); | |
1640 break; | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1641 }; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1642 return res; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1643 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1644 |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1645 /** |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1646 * 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
|
1647 * |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1648 * @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
|
1649 * @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
|
1650 */ |
10004 | 1651 static void apply_tns(float coef[1024], TemporalNoiseShaping *tns, |
1652 IndividualChannelStream *ics, int decode) | |
1653 { | |
1654 const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb); | |
7636 | 1655 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
|
1656 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
|
1657 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
|
1658 |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1659 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
|
1660 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
|
1661 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
|
1662 top = bottom; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1663 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
|
1664 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
|
1665 if (order == 0) |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1666 continue; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1667 |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1668 // tns_decode_coef |
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1669 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
|
1670 |
7609 | 1671 start = ics->swb_offset[FFMIN(bottom, mmm)]; |
1672 end = ics->swb_offset[FFMIN( top, mmm)]; | |
1673 if ((size = end - start) <= 0) | |
1674 continue; | |
1675 if (tns->direction[w][filt]) { | |
10004 | 1676 inc = -1; |
1677 start = end - 1; | |
7609 | 1678 } else { |
1679 inc = 1; | |
1680 } | |
1681 start += w * 128; | |
1682 | |
1683 // ar filter | |
1684 for (m = 0; m < size; m++, start += inc) | |
1685 for (i = 1; i <= FFMIN(m, order); i++) | |
10004 | 1686 coef[start] -= coef[start - i * inc] * lpc[i - 1]; |
7609 | 1687 } |
1688 } | |
1689 } | |
1690 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1691 /** |
7539 | 1692 * Conduct IMDCT and windowing. |
1693 */ | |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1694 static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce, float bias) |
10004 | 1695 { |
1696 IndividualChannelStream *ics = &sce->ics; | |
1697 float *in = sce->coeffs; | |
1698 float *out = sce->ret; | |
1699 float *saved = sce->saved; | |
1700 const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; | |
1701 const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; | |
1702 const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; | |
1703 float *buf = ac->buf_mdct; | |
1704 float *temp = ac->temp; | |
7539 | 1705 int i; |
1706 | |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1707 // imdct |
7578 | 1708 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
|
1709 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
|
1710 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
|
1711 } else |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1712 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
|
1713 |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1714 /* window overlapping |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1715 * 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
|
1716 * 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
|
1717 * 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
|
1718 * 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
|
1719 */ |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1720 if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) && |
10004 | 1721 (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) { |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1722 ac->dsp.vector_fmul_window( out, saved, buf, lwindow_prev, bias, 512); |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1723 } else { |
7662 | 1724 for (i = 0; i < 448; i++) |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1725 out[i] = saved[i] + bias; |
7578 | 1726 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1727 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1728 ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448, buf + 0*128, swindow_prev, bias, 64); |
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1729 ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow, bias, 64); |
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1730 ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow, bias, 64); |
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1731 ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow, bias, 64); |
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1732 ac->dsp.vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, swindow, bias, 64); |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1733 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
|
1734 } else { |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1735 ac->dsp.vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, bias, 64); |
7662 | 1736 for (i = 576; i < 1024; i++) |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1737 out[i] = buf[i-512] + bias; |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1738 } |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1739 } |
7578 | 1740 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1741 // buffer update |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1742 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
|
1743 for (i = 0; i < 64; i++) |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1744 saved[i] = temp[64 + i] - bias; |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1745 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
|
1746 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
|
1747 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
|
1748 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
|
1749 } 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
|
1750 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
|
1751 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
|
1752 } 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
|
1753 memcpy( saved, buf + 512, 512 * sizeof(float)); |
7578 | 1754 } |
1755 } | |
1756 | |
7539 | 1757 /** |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1758 * 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
|
1759 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1760 * @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
|
1761 */ |
10004 | 1762 static void apply_dependent_coupling(AACContext *ac, |
1763 SingleChannelElement *target, | |
1764 ChannelElement *cce, int index) | |
1765 { | |
1766 IndividualChannelStream *ics = &cce->ch[0].ics; | |
1767 const uint16_t *offsets = ics->swb_offset; | |
1768 float *dest = target->coeffs; | |
1769 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
|
1770 int g, i, group, k, idx = 0; |
10004 | 1771 if (ac->m4ac.object_type == AOT_AAC_LTP) { |
11833 | 1772 av_log(ac->avctx, AV_LOG_ERROR, |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1773 "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
|
1774 return; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1775 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1776 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
|
1777 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
|
1778 if (cce->ch[0].band_type[idx] != ZERO_BT) { |
9143 | 1779 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
|
1780 for (group = 0; group < ics->group_len[g]; group++) { |
10004 | 1781 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
|
1782 // XXX dsputil-ize |
10004 | 1783 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
|
1784 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1785 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1786 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1787 } |
10004 | 1788 dest += ics->group_len[g] * 128; |
1789 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
|
1790 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1791 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1792 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1793 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1794 * 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
|
1795 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1796 * @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
|
1797 */ |
10004 | 1798 static void apply_independent_coupling(AACContext *ac, |
1799 SingleChannelElement *target, | |
1800 ChannelElement *cce, int index) | |
1801 { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1802 int i; |
9051
0cffed11ee33
Use const to better allow the compiler to optimize AAC independent coupling.
alexc
parents:
8823
diff
changeset
|
1803 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
|
1804 const float bias = ac->add_bias; |
10004 | 1805 const float *src = cce->ch[0].ret; |
1806 float *dest = target->ret; | |
11401 | 1807 const int len = 1024 << (ac->m4ac.sbr == 1); |
9051
0cffed11ee33
Use const to better allow the compiler to optimize AAC independent coupling.
alexc
parents:
8823
diff
changeset
|
1808 |
11401 | 1809 for (i = 0; i < len; i++) |
9051
0cffed11ee33
Use const to better allow the compiler to optimize AAC independent coupling.
alexc
parents:
8823
diff
changeset
|
1810 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
|
1811 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1812 |
7581 | 1813 /** |
1814 * channel coupling transformation interface | |
1815 * | |
1816 * @param apply_coupling_method pointer to (in)dependent coupling function | |
1817 */ | |
10004 | 1818 static void apply_channel_coupling(AACContext *ac, ChannelElement *cc, |
1819 enum RawDataBlockType type, int elem_id, | |
1820 enum CouplingPoint coupling_point, | |
1821 void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)) | |
7581 | 1822 { |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1823 int i, c; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1824 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1825 for (i = 0; i < MAX_ELEM_ID; i++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1826 ChannelElement *cce = ac->che[TYPE_CCE][i]; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1827 int index = 0; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1828 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1829 if (cce && cce->coup.coupling_point == coupling_point) { |
10004 | 1830 ChannelCoupling *coup = &cce->coup; |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1831 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1832 for (c = 0; c <= coup->num_coupled; c++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1833 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
|
1834 if (coup->ch_select[c] != 1) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1835 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
|
1836 if (coup->ch_select[c] != 0) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1837 index++; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1838 } |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1839 if (coup->ch_select[c] != 2) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1840 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
|
1841 } else |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1842 index += 1 + (coup->ch_select[c] == 3); |
7581 | 1843 } |
1844 } | |
1845 } | |
1846 } | |
1847 | |
1848 /** | |
1849 * Convert spectral data to float samples, applying all supported tools as appropriate. | |
1850 */ | |
10004 | 1851 static void spectral_to_sample(AACContext *ac) |
1852 { | |
10688 | 1853 int i, type; |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1854 float imdct_bias = (ac->m4ac.sbr <= 0) ? ac->add_bias : 0.0f; |
10688 | 1855 for (type = 3; type >= 0; type--) { |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1856 for (i = 0; i < MAX_ELEM_ID; i++) { |
7581 | 1857 ChannelElement *che = ac->che[type][i]; |
10004 | 1858 if (che) { |
1859 if (type <= TYPE_CPE) | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1860 apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling); |
10004 | 1861 if (che->ch[0].tns.present) |
7581 | 1862 apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1); |
10004 | 1863 if (che->ch[1].tns.present) |
7581 | 1864 apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1); |
10004 | 1865 if (type <= TYPE_CPE) |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1866 apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling); |
11401 | 1867 if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) { |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1868 imdct_and_windowing(ac, &che->ch[0], imdct_bias); |
11668 | 1869 if (type == TYPE_CPE) { |
1870 imdct_and_windowing(ac, &che->ch[1], imdct_bias); | |
1871 } | |
11667
6818ea5a25a2
Rewrite ff_sbr_apply in a manner more friendly to PS.
alexc
parents:
11644
diff
changeset
|
1872 if (ac->m4ac.sbr > 0) { |
6818ea5a25a2
Rewrite ff_sbr_apply in a manner more friendly to PS.
alexc
parents:
11644
diff
changeset
|
1873 ff_sbr_apply(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret); |
6818ea5a25a2
Rewrite ff_sbr_apply in a manner more friendly to PS.
alexc
parents:
11644
diff
changeset
|
1874 } |
11401 | 1875 } |
10004 | 1876 if (type <= TYPE_CCE) |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1877 apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling); |
7578 | 1878 } |
1879 } | |
1880 } | |
1881 } | |
1882 | |
10004 | 1883 static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb) |
1884 { | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1885 int size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1886 AACADTSHeaderInfo hdr_info; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1887 |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1888 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
|
1889 if (size > 0) { |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1890 if (ac->output_configured != OC_LOCKED && hdr_info.chan_config) { |
9948
98fd723f72e7
Ignore subsequent channel configurations after the first in an AAC file. The
alexc
parents:
9891
diff
changeset
|
1891 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
|
1892 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
|
1893 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
|
1894 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
|
1895 return -7; |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1896 if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config, OC_TRIAL_FRAME)) |
9948
98fd723f72e7
Ignore subsequent channel configurations after the first in an AAC file. The
alexc
parents:
9891
diff
changeset
|
1897 return -7; |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1898 } else if (ac->output_configured != OC_LOCKED) { |
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1899 ac->output_configured = OC_NONE; |
9948
98fd723f72e7
Ignore subsequent channel configurations after the first in an AAC file. The
alexc
parents:
9891
diff
changeset
|
1900 } |
11886 | 1901 if (ac->output_configured != OC_LOCKED) { |
10621
62b3faabb663
Set the SBR mode to implicit on ADTS frames occurring before the output is locked.
alexc
parents:
10551
diff
changeset
|
1902 ac->m4ac.sbr = -1; |
11886 | 1903 ac->m4ac.ps = -1; |
1904 } | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1905 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
|
1906 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
|
1907 ac->m4ac.object_type = hdr_info.object_type; |
11833 | 1908 if (!ac->avctx->sample_rate) |
1909 ac->avctx->sample_rate = hdr_info.sample_rate; | |
9151 | 1910 if (hdr_info.num_aac_frames == 1) { |
1911 if (!hdr_info.crc_absent) | |
1912 skip_bits(gb, 16); | |
1913 } else { | |
11833 | 1914 av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame is", 0); |
9151 | 1915 return -1; |
1916 } | |
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
|
1917 } |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1918 return size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1919 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1920 |
11833 | 1921 static int aac_decode_frame(AVCodecContext *avctx, void *data, |
10004 | 1922 int *data_size, AVPacket *avpkt) |
1923 { | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9251
diff
changeset
|
1924 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9251
diff
changeset
|
1925 int buf_size = avpkt->size; |
11833 | 1926 AACContext *ac = avctx->priv_data; |
11401 | 1927 ChannelElement *che = NULL, *che_prev = NULL; |
7578 | 1928 GetBitContext gb; |
11401 | 1929 enum RawDataBlockType elem_type, elem_type_prev = TYPE_END; |
7578 | 1930 int err, elem_id, data_size_tmp; |
11362
1682a19a0881
AAC: Return the number of bytes consumed in decoding a frame.
alexc
parents:
11358
diff
changeset
|
1931 int buf_consumed; |
11902 | 1932 int samples = 0, multiplier; |
11746
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
1933 int buf_offset; |
7578 | 1934 |
10004 | 1935 init_get_bits(&gb, buf, buf_size * 8); |
7578 | 1936 |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1937 if (show_bits(&gb, 12) == 0xfff) { |
9510 | 1938 if (parse_adts_frame_header(ac, &gb) < 0) { |
11833 | 1939 av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n"); |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1940 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1941 } |
8812 | 1942 if (ac->m4ac.sampling_index > 12) { |
11833 | 1943 av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); |
8789 | 1944 return -1; |
1945 } | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1946 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1947 |
12483
0159a19bfff7
aacdec: Rework channel mapping compatibility hacks.
alexc
parents:
12260
diff
changeset
|
1948 ac->tags_mapped = 0; |
7578 | 1949 // parse |
1950 while ((elem_type = get_bits(&gb, 3)) != TYPE_END) { | |
1951 elem_id = get_bits(&gb, 4); | |
1952 | |
11903 | 1953 if (elem_type < TYPE_DSE) { |
11904 | 1954 if (!(che=get_che(ac, elem_type, elem_id))) { |
1955 av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", | |
1956 elem_type, elem_id); | |
1957 return -1; | |
1958 } | |
11902 | 1959 samples = 1024; |
11903 | 1960 } |
11902 | 1961 |
7578 | 1962 switch (elem_type) { |
1963 | |
1964 case TYPE_SCE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1965 err = decode_ics(ac, &che->ch[0], &gb, 0, 0); |
7578 | 1966 break; |
1967 | |
1968 case TYPE_CPE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1969 err = decode_cpe(ac, &gb, che); |
7578 | 1970 break; |
1971 | |
1972 case TYPE_CCE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1973 err = decode_cce(ac, &gb, che); |
7578 | 1974 break; |
1975 | |
1976 case TYPE_LFE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1977 err = decode_ics(ac, &che->ch[0], &gb, 0, 0); |
7578 | 1978 break; |
1979 | |
1980 case TYPE_DSE: | |
11205 | 1981 err = skip_data_stream_element(ac, &gb); |
7578 | 1982 break; |
1983 | |
10004 | 1984 case TYPE_PCE: { |
7578 | 1985 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; |
1986 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
10004 | 1987 if ((err = decode_pce(ac, new_che_pos, &gb))) |
7578 | 1988 break; |
10551
a0dd118e82ae
10l: Fix inverted if-condition from r20448. Fixes issue 1562.
alexc
parents:
10519
diff
changeset
|
1989 if (ac->output_configured > OC_TRIAL_PCE) |
11833 | 1990 av_log(avctx, AV_LOG_ERROR, |
9948
98fd723f72e7
Ignore subsequent channel configurations after the first in an AAC file. The
alexc
parents:
9891
diff
changeset
|
1991 "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
|
1992 else |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1993 err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE); |
7578 | 1994 break; |
1995 } | |
1996 | |
1997 case TYPE_FIL: | |
1998 if (elem_id == 15) | |
1999 elem_id += get_bits(&gb, 8) - 1; | |
11205 | 2000 if (get_bits_left(&gb) < 8 * elem_id) { |
11833 | 2001 av_log(avctx, AV_LOG_ERROR, overread_err); |
11205 | 2002 return -1; |
2003 } | |
7578 | 2004 while (elem_id > 0) |
11401 | 2005 elem_id -= decode_extension_payload(ac, &gb, elem_id, che_prev, elem_type_prev); |
7578 | 2006 err = 0; /* FIXME */ |
2007 break; | |
2008 | |
2009 default: | |
2010 err = -1; /* should not happen, but keeps compiler happy */ | |
2011 break; | |
2012 } | |
2013 | |
11401 | 2014 che_prev = che; |
2015 elem_type_prev = elem_type; | |
2016 | |
10004 | 2017 if (err) |
7578 | 2018 return err; |
11205 | 2019 |
2020 if (get_bits_left(&gb) < 3) { | |
11833 | 2021 av_log(avctx, AV_LOG_ERROR, overread_err); |
11205 | 2022 return -1; |
2023 } | |
7578 | 2024 } |
2025 | |
2026 spectral_to_sample(ac); | |
2027 | |
11401 | 2028 multiplier = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0; |
11393
d23864bc3887
AAC: Set codec parameters in the first frame rather than in .init()
alexc
parents:
11388
diff
changeset
|
2029 samples <<= multiplier; |
d23864bc3887
AAC: Set codec parameters in the first frame rather than in .init()
alexc
parents:
11388
diff
changeset
|
2030 if (ac->output_configured < OC_LOCKED) { |
11833 | 2031 avctx->sample_rate = ac->m4ac.sample_rate << multiplier; |
2032 avctx->frame_size = samples; | |
11393
d23864bc3887
AAC: Set codec parameters in the first frame rather than in .init()
alexc
parents:
11388
diff
changeset
|
2033 } |
d23864bc3887
AAC: Set codec parameters in the first frame rather than in .init()
alexc
parents:
11388
diff
changeset
|
2034 |
11833 | 2035 data_size_tmp = samples * avctx->channels * sizeof(int16_t); |
10004 | 2036 if (*data_size < data_size_tmp) { |
11833 | 2037 av_log(avctx, AV_LOG_ERROR, |
7539 | 2038 "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n", |
2039 *data_size, data_size_tmp); | |
2040 return -1; | |
2041 } | |
2042 *data_size = data_size_tmp; | |
2043 | |
11902 | 2044 if (samples) |
11905 | 2045 ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels); |
7539 | 2046 |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2047 if (ac->output_configured) |
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2048 ac->output_configured = OC_LOCKED; |
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2049 |
11362
1682a19a0881
AAC: Return the number of bytes consumed in decoding a frame.
alexc
parents:
11358
diff
changeset
|
2050 buf_consumed = (get_bits_count(&gb) + 7) >> 3; |
11746
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2051 for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++) |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2052 if (buf[buf_offset]) |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2053 break; |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2054 |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2055 return buf_size > buf_offset ? buf_consumed : buf_size; |
7539 | 2056 } |
2057 | |
11833 | 2058 static av_cold int aac_decode_close(AVCodecContext *avctx) |
10004 | 2059 { |
11833 | 2060 AACContext *ac = avctx->priv_data; |
7540 | 2061 int i, type; |
7501 | 2062 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
2063 for (i = 0; i < MAX_ELEM_ID; i++) { |
11401 | 2064 for (type = 0; type < 4; type++) { |
2065 if (ac->che[type][i]) | |
2066 ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr); | |
7540 | 2067 av_freep(&ac->che[type][i]); |
11401 | 2068 } |
7501 | 2069 } |
2070 | |
2071 ff_mdct_end(&ac->mdct); | |
2072 ff_mdct_end(&ac->mdct_small); | |
10004 | 2073 return 0; |
7501 | 2074 } |
2075 | |
2076 AVCodec aac_decoder = { | |
2077 "aac", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11489
diff
changeset
|
2078 AVMEDIA_TYPE_AUDIO, |
7501 | 2079 CODEC_ID_AAC, |
2080 sizeof(AACContext), | |
2081 aac_decode_init, | |
2082 NULL, | |
2083 aac_decode_close, | |
2084 aac_decode_frame, | |
2085 .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"), | |
10145
7955db355703
Make sample_fmts and channel_layouts compound literals const to reduce size of
reimar
parents:
10004
diff
changeset
|
2086 .sample_fmts = (const enum SampleFormat[]) { |
10004 | 2087 SAMPLE_FMT_S16,SAMPLE_FMT_NONE |
2088 }, | |
10306
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
2089 .channel_layouts = aac_channel_layout, |
7501 | 2090 }; |