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