Mercurial > libavcodec.hg
annotate aacdec.c @ 12043:f9a0bd0888a4 libavcodec
mpegaudio: call ff_mpegaudiodec_init_mmx() only from float decoder
The mmx code is floating-point only, and this function does not know
from which decoder it is called. Without this change, the integer
decoder only "works" because the size of the context struct is smaller
in this case, and the mmx init function writes the function pointer
outside the allocated context.
author | mru |
---|---|
date | Thu, 01 Jul 2010 23:21:17 +0000 |
parents | ebe049799f6d |
children | c69dd071f7d4 |
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 |
11833 | 541 ac->avctx = avctx; |
542 ac->m4ac.sample_rate = avctx->sample_rate; | |
7501 | 543 |
11833 | 544 if (avctx->extradata_size > 0) { |
545 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
|
546 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
547 } |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
548 |
11833 | 549 avctx->sample_fmt = SAMPLE_FMT_S16; |
7501 | 550 |
10877 | 551 AAC_INIT_VLC_STATIC( 0, 304); |
552 AAC_INIT_VLC_STATIC( 1, 270); | |
553 AAC_INIT_VLC_STATIC( 2, 550); | |
554 AAC_INIT_VLC_STATIC( 3, 300); | |
555 AAC_INIT_VLC_STATIC( 4, 328); | |
556 AAC_INIT_VLC_STATIC( 5, 294); | |
557 AAC_INIT_VLC_STATIC( 6, 306); | |
558 AAC_INIT_VLC_STATIC( 7, 268); | |
559 AAC_INIT_VLC_STATIC( 8, 510); | |
560 AAC_INIT_VLC_STATIC( 9, 366); | |
561 AAC_INIT_VLC_STATIC(10, 462); | |
7501 | 562 |
11401 | 563 ff_aac_sbr_init(); |
564 | |
11833 | 565 dsputil_init(&ac->dsp, avctx); |
7501 | 566 |
7539 | 567 ac->random_state = 0x1f2e3d4c; |
568 | |
7501 | 569 // -1024 - Compensate wrong IMDCT method. |
570 // 32768 - Required to scale values to the correct range for the bias method | |
571 // for float to int16 conversion. | |
572 | |
10377
98816e4d5522
dca and aac decoders use float_to_int16_interleave, so check for
conrad
parents:
10308
diff
changeset
|
573 if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) { |
10004 | 574 ac->add_bias = 385.0f; |
575 ac->sf_scale = 1. / (-1024. * 32768.); | |
7501 | 576 ac->sf_offset = 0; |
577 } else { | |
10004 | 578 ac->add_bias = 0.0f; |
579 ac->sf_scale = 1. / -1024.; | |
7501 | 580 ac->sf_offset = 60; |
581 } | |
582 | |
11932 | 583 ff_aac_tableinit(); |
7501 | 584 |
8042 | 585 INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code), |
10004 | 586 ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]), |
587 ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]), | |
588 352); | |
7501 | 589 |
9658
67a20f0eb42c
Support for getting (i)MDCT output multiplied by a constant scaling factor.
serge
parents:
9634
diff
changeset
|
590 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
|
591 ff_mdct_init(&ac->mdct_small, 8, 1, 1.0); |
7581 | 592 // window initialization |
593 ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024); | |
594 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
|
595 ff_init_ff_sine_windows(10); |
3d011a01a6a0
Add support for hard-coded MDCT-related ff_sine_windows tables.
reimar
parents:
10819
diff
changeset
|
596 ff_init_ff_sine_windows( 7); |
7581 | 597 |
11489
1aba21918874
Allow hard-coding of the 32kB cubic-root table for AAC.
reimar
parents:
11481
diff
changeset
|
598 cbrt_tableinit(); |
10849 | 599 |
7501 | 600 return 0; |
601 } | |
602 | |
7539 | 603 /** |
604 * Skip data_stream_element; reference: table 4.10. | |
605 */ | |
11205 | 606 static int skip_data_stream_element(AACContext *ac, GetBitContext *gb) |
10004 | 607 { |
7501 | 608 int byte_align = get_bits1(gb); |
609 int count = get_bits(gb, 8); | |
610 if (count == 255) | |
611 count += get_bits(gb, 8); | |
612 if (byte_align) | |
613 align_get_bits(gb); | |
11205 | 614 |
615 if (get_bits_left(gb) < 8 * count) { | |
11833 | 616 av_log(ac->avctx, AV_LOG_ERROR, overread_err); |
11205 | 617 return -1; |
618 } | |
7501 | 619 skip_bits_long(gb, 8 * count); |
11205 | 620 return 0; |
7501 | 621 } |
622 | |
10004 | 623 static int decode_prediction(AACContext *ac, IndividualChannelStream *ics, |
624 GetBitContext *gb) | |
625 { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
626 int sfb; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
627 if (get_bits1(gb)) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
628 ics->predictor_reset_group = get_bits(gb, 5); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
629 if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) { |
11833 | 630 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
|
631 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
632 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
633 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
634 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
|
635 ics->prediction_used[sfb] = get_bits1(gb); |
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 return 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
638 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
639 |
7501 | 640 /** |
7539 | 641 * Decode Individual Channel Stream info; reference: table 4.6. |
642 * | |
643 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
644 */ | |
10004 | 645 static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics, |
646 GetBitContext *gb, int common_window) | |
647 { | |
7539 | 648 if (get_bits1(gb)) { |
11833 | 649 av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n"); |
7539 | 650 memset(ics, 0, sizeof(IndividualChannelStream)); |
651 return -1; | |
652 } | |
653 ics->window_sequence[1] = ics->window_sequence[0]; | |
654 ics->window_sequence[0] = get_bits(gb, 2); | |
10004 | 655 ics->use_kb_window[1] = ics->use_kb_window[0]; |
656 ics->use_kb_window[0] = get_bits1(gb); | |
657 ics->num_window_groups = 1; | |
658 ics->group_len[0] = 1; | |
7581 | 659 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
660 int i; | |
661 ics->max_sfb = get_bits(gb, 4); | |
662 for (i = 0; i < 7; i++) { | |
663 if (get_bits1(gb)) { | |
10004 | 664 ics->group_len[ics->num_window_groups - 1]++; |
7581 | 665 } else { |
666 ics->num_window_groups++; | |
10004 | 667 ics->group_len[ics->num_window_groups - 1] = 1; |
7581 | 668 } |
669 } | |
10004 | 670 ics->num_windows = 8; |
671 ics->swb_offset = ff_swb_offset_128[ac->m4ac.sampling_index]; | |
672 ics->num_swb = ff_aac_num_swb_128[ac->m4ac.sampling_index]; | |
673 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
|
674 ics->predictor_present = 0; |
7581 | 675 } else { |
10004 | 676 ics->max_sfb = get_bits(gb, 6); |
677 ics->num_windows = 1; | |
678 ics->swb_offset = ff_swb_offset_1024[ac->m4ac.sampling_index]; | |
679 ics->num_swb = ff_aac_num_swb_1024[ac->m4ac.sampling_index]; | |
680 ics->tns_max_bands = ff_tns_max_bands_1024[ac->m4ac.sampling_index]; | |
681 ics->predictor_present = get_bits1(gb); | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
682 ics->predictor_reset_group = 0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
683 if (ics->predictor_present) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
684 if (ac->m4ac.object_type == AOT_AAC_MAIN) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
685 if (decode_prediction(ac, ics, gb)) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
686 memset(ics, 0, sizeof(IndividualChannelStream)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
687 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
688 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
689 } else if (ac->m4ac.object_type == AOT_AAC_LC) { |
11833 | 690 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
|
691 memset(ics, 0, sizeof(IndividualChannelStream)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
692 return -1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
693 } else { |
11833 | 694 av_log_missing_feature(ac->avctx, "Predictor bit set but LTP is", 1); |
8200 | 695 memset(ics, 0, sizeof(IndividualChannelStream)); |
696 return -1; | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
697 } |
7578 | 698 } |
699 } | |
700 | |
10004 | 701 if (ics->max_sfb > ics->num_swb) { |
11833 | 702 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 703 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n", |
704 ics->max_sfb, ics->num_swb); | |
7578 | 705 memset(ics, 0, sizeof(IndividualChannelStream)); |
706 return -1; | |
707 } | |
708 | |
7539 | 709 return 0; |
710 } | |
711 | |
712 /** | |
713 * Decode band types (section_data payload); reference: table 4.46. | |
714 * | |
715 * @param band_type array of the used band type | |
716 * @param band_type_run_end array of the last scalefactor band of a band type run | |
717 * | |
718 * @return Returns error status. 0 - OK, !0 - error | |
719 */ | |
10004 | 720 static int decode_band_types(AACContext *ac, enum BandType band_type[120], |
721 int band_type_run_end[120], GetBitContext *gb, | |
722 IndividualChannelStream *ics) | |
723 { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
724 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
|
725 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
|
726 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
|
727 int k = 0; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
728 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
|
729 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
|
730 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
|
731 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
|
732 if (sect_band_type == 12) { |
11833 | 733 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
|
734 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
735 } |
10004 | 736 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
|
737 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
|
738 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
|
739 if (get_bits_left(gb) < 0) { |
11833 | 740 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
|
741 return -1; |
11fb96e94573
aac: Keep decode_band_types() from eating all padding at the end of a buffer.
alexc
parents:
11205
diff
changeset
|
742 } |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
743 if (sect_end > ics->max_sfb) { |
11833 | 744 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 745 "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
|
746 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
|
747 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
748 } |
10519
06d6393bbaeb
AAC: Rename sect_len to sect_end. It marks the last sfb of the section, not the
alexc
parents:
10491
diff
changeset
|
749 for (; k < sect_end; k++) { |
7581 | 750 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
|
751 band_type_run_end[idx++] = sect_end; |
7581 | 752 } |
7539 | 753 } |
754 } | |
755 return 0; | |
756 } | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
757 |
7539 | 758 /** |
759 * 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
|
760 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
761 * @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
|
762 * @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
|
763 * @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
|
764 * @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
|
765 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
766 * @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
|
767 */ |
10004 | 768 static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb, |
769 unsigned int global_gain, | |
770 IndividualChannelStream *ics, | |
771 enum BandType band_type[120], | |
772 int band_type_run_end[120]) | |
773 { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
774 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
|
775 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
|
776 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
|
777 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
|
778 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
|
779 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
|
780 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
|
781 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
|
782 if (band_type[idx] == ZERO_BT) { |
10004 | 783 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
|
784 sf[idx] = 0.; |
10004 | 785 } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) { |
786 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
|
787 offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
10004 | 788 if (offset[2] > 255U) { |
11833 | 789 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 790 "%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
|
791 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
792 } |
10004 | 793 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
|
794 } |
10004 | 795 } else if (band_type[idx] == NOISE_BT) { |
796 for (; i < run_end; i++, idx++) { | |
797 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
|
798 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
|
799 else |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
800 offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
10004 | 801 if (offset[1] > 255U) { |
11833 | 802 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 803 "%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
|
804 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
805 } |
10004 | 806 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
|
807 } |
10004 | 808 } else { |
809 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
|
810 offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; |
10004 | 811 if (offset[0] > 255U) { |
11833 | 812 av_log(ac->avctx, AV_LOG_ERROR, |
10004 | 813 "%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
|
814 return -1; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
815 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
816 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
|
817 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
818 } |
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 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
821 return 0; |
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 * 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
|
826 */ |
10004 | 827 static int decode_pulses(Pulse *pulse, GetBitContext *gb, |
828 const uint16_t *swb_offset, int num_swb) | |
829 { | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
830 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
|
831 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
|
832 pulse_swb = get_bits(gb, 6); |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
833 if (pulse_swb >= num_swb) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
834 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
835 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
|
836 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
|
837 if (pulse->pos[0] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
838 return -1; |
7580 | 839 pulse->amp[0] = get_bits(gb, 4); |
840 for (i = 1; i < pulse->num_pulse; i++) { | |
10004 | 841 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
|
842 if (pulse->pos[i] > 1023) |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
843 return -1; |
7580 | 844 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
|
845 } |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
846 return 0; |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
847 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
848 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
849 /** |
7609 | 850 * Decode Temporal Noise Shaping data; reference: table 4.48. |
851 * | |
852 * @return Returns error status. 0 - OK, !0 - error | |
853 */ | |
10004 | 854 static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns, |
855 GetBitContext *gb, const IndividualChannelStream *ics) | |
856 { | |
7609 | 857 int w, filt, i, coef_len, coef_res, coef_compress; |
858 const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE; | |
859 const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12; | |
860 for (w = 0; w < ics->num_windows; w++) { | |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
861 if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) { |
7609 | 862 coef_res = get_bits1(gb); |
863 | |
7638 | 864 for (filt = 0; filt < tns->n_filt[w]; filt++) { |
865 int tmp2_idx; | |
10004 | 866 tns->length[w][filt] = get_bits(gb, 6 - 2 * is8); |
7609 | 867 |
10004 | 868 if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) { |
11833 | 869 av_log(ac->avctx, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n", |
7638 | 870 tns->order[w][filt], tns_max_order); |
871 tns->order[w][filt] = 0; | |
872 return -1; | |
873 } | |
7850
77030651ddd0
Only read some of TNS bitstream data in the case that the TNS filter order is
superdump
parents:
7845
diff
changeset
|
874 if (tns->order[w][filt]) { |
7851 | 875 tns->direction[w][filt] = get_bits1(gb); |
876 coef_compress = get_bits1(gb); | |
877 coef_len = coef_res + 3 - coef_compress; | |
10004 | 878 tmp2_idx = 2 * coef_compress + coef_res; |
7638 | 879 |
7851 | 880 for (i = 0; i < tns->order[w][filt]; i++) |
881 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
|
882 } |
7609 | 883 } |
7637
1fd8e319e8b6
Work around GCC variable may be used uninitialised warning
superdump
parents:
7636
diff
changeset
|
884 } |
7609 | 885 } |
886 return 0; | |
887 } | |
888 | |
889 /** | |
7539 | 890 * Decode Mid/Side data; reference: table 4.54. |
891 * | |
892 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
893 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
894 * [3] reserved for scalable AAC | |
895 */ | |
10004 | 896 static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb, |
897 int ms_present) | |
898 { | |
7578 | 899 int idx; |
900 if (ms_present == 1) { | |
901 for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++) | |
902 cpe->ms_mask[idx] = get_bits1(gb); | |
903 } else if (ms_present == 2) { | |
904 memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0])); | |
905 } | |
906 } | |
7539 | 907 |
10881 | 908 #ifndef VMUL2 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
909 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
|
910 const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
911 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
912 float s = *scale; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
913 *dst++ = v[idx & 15] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
914 *dst++ = v[idx>>4 & 15] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
915 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
916 } |
10881 | 917 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
918 |
10881 | 919 #ifndef VMUL4 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
920 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
|
921 const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
922 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
923 float s = *scale; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
924 *dst++ = v[idx & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
925 *dst++ = v[idx>>2 & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
926 *dst++ = v[idx>>4 & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
927 *dst++ = v[idx>>6 & 3] * s; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
928 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
929 } |
10881 | 930 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
931 |
10881 | 932 #ifndef VMUL2S |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
933 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
|
934 unsigned sign, const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
935 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
936 union float754 s0, s1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
937 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
938 s0.f = s1.f = *scale; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
939 s0.i ^= sign >> 1 << 31; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
940 s1.i ^= sign << 31; |
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 *dst++ = v[idx & 15] * s0.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
943 *dst++ = v[idx>>4 & 15] * s1.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
944 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
945 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
946 } |
10881 | 947 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
948 |
10881 | 949 #ifndef VMUL4S |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
950 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
|
951 unsigned sign, const float *scale) |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
952 { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
953 unsigned nz = idx >> 12; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
954 union float754 s = { .f = *scale }; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
955 union float754 t; |
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 t.i = s.i ^ (sign & 1<<31); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
958 *dst++ = v[idx & 3] * t.f; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
959 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
960 sign <<= nz & 1; nz >>= 1; |
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>>2 & 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>>4 & 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>>6 & 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 return dst; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
973 } |
10881 | 974 #endif |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
975 |
7539 | 976 /** |
7581 | 977 * Decode spectral data; reference: table 4.50. |
978 * Dequantize and scale spectral data; reference: 4.6.3.3. | |
979 * | |
980 * @param coef array of dequantized, scaled spectral data | |
981 * @param sf array of scalefactors or intensity stereo positions | |
982 * @param pulse_present set if pulses are present | |
983 * @param pulse pointer to pulse data struct | |
984 * @param band_type array of the used band type | |
985 * | |
986 * @return Returns error status. 0 - OK, !0 - error | |
987 */ | |
10004 | 988 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
|
989 GetBitContext *gb, const float sf[120], |
10004 | 990 int pulse_present, const Pulse *pulse, |
991 const IndividualChannelStream *ics, | |
992 enum BandType band_type[120]) | |
993 { | |
7581 | 994 int i, k, g, idx = 0; |
10004 | 995 const int c = 1024 / ics->num_windows; |
996 const uint16_t *offsets = ics->swb_offset; | |
7581 | 997 float *coef_base = coef; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
998 int err_idx; |
7581 | 999 |
1000 for (g = 0; g < ics->num_windows; g++) | |
10004 | 1001 memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb])); |
7581 | 1002 |
1003 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
|
1004 unsigned g_len = ics->group_len[g]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1005 |
7581 | 1006 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
|
1007 const unsigned cbt_m1 = band_type[idx] - 1; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1008 float *cfo = coef + offsets[i]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1009 int off_len = offsets[i + 1] - offsets[i]; |
7581 | 1010 int group; |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1011 |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1012 if (cbt_m1 >= INTENSITY_BT2 - 1) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1013 for (group = 0; group < g_len; group++, cfo+=128) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1014 memset(cfo, 0, off_len * sizeof(float)); |
7581 | 1015 } |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1016 } else if (cbt_m1 == NOISE_BT - 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) { |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
1018 float scale; |
10252 | 1019 float band_energy; |
10220 | 1020 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1021 for (k = 0; k < off_len; k++) { |
7581 | 1022 ac->random_state = lcg_random(ac->random_state); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1023 cfo[k] = ac->random_state; |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
1024 } |
10220 | 1025 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1026 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
|
1027 scale = sf[idx] / sqrtf(band_energy); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1028 ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len); |
7581 | 1029 } |
10004 | 1030 } else { |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1031 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
|
1032 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
|
1033 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
|
1034 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
|
1035 OPEN_READER(re, gb); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1036 |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1037 switch (cbt_m1 >> 1) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1038 case 0: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1039 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
|
1040 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1041 int len = off_len; |
10220 | 1042 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1043 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1044 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1045 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1046 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1047 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1048 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1049 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1050 if (code >= cb_size) { |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1051 err_idx = code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1052 goto err_cb_overflow; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1053 } |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1054 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1055 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1056 cf = VMUL4(cf, vq, cb_idx, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1057 } while (len -= 4); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1058 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1059 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1060 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1061 case 1: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1062 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
|
1063 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1064 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1065 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1066 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1067 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1068 unsigned nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1069 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1070 uint32_t bits; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1071 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1072 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1073 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1074 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1075 if (code >= cb_size) { |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1076 err_idx = code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1077 goto err_cb_overflow; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1078 } |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1079 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1080 #if MIN_CACHE_BITS < 20 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1081 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1082 #endif |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1083 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1084 nnz = cb_idx >> 8 & 15; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1085 bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1086 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1087 cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1088 } while (len -= 4); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1089 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1090 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1091 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1092 case 2: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1093 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
|
1094 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1095 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1096 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1097 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1098 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1099 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1100 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1101 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1102 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1103 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1104 if (code >= cb_size) { |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1105 err_idx = code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1106 goto err_cb_overflow; |
8283
ea8e4095d980
AAC: Unroll code within decode_spectrum_and_dequant(). Gives 12% net speed gain.
superdump
parents:
8282
diff
changeset
|
1107 } |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1108 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1109 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1110 cf = VMUL2(cf, vq, cb_idx, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1111 } while (len -= 2); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1112 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1113 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1114 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1115 case 3: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1116 case 4: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1117 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
|
1118 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1119 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1120 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1121 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1122 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1123 unsigned nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1124 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1125 unsigned sign; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1126 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1127 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1128 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1129 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1130 if (code >= cb_size) { |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1131 err_idx = code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1132 goto err_cb_overflow; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1133 } |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1134 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1135 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1136 nnz = cb_idx >> 8 & 15; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1137 sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1138 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1139 cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1140 } while (len -= 2); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1141 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1142 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1143 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1144 default: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1145 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
|
1146 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1147 uint32_t *icf = (uint32_t *) cf; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1148 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1149 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1150 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1151 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1152 unsigned nzt, nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1153 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1154 uint32_t bits; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1155 int j; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1156 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1157 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1158 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1159 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1160 if (!code) { |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1161 *icf++ = 0; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1162 *icf++ = 0; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1163 continue; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1164 } |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1165 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1166 if (code >= cb_size) { |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1167 err_idx = code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1168 goto err_cb_overflow; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1169 } |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1170 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1171 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1172 nnz = cb_idx >> 12; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1173 nzt = cb_idx >> 8; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1174 bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1175 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1176 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1177 for (j = 0; j < 2; j++) { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1178 if (nzt & 1<<j) { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1179 uint32_t b; |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1180 int n; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1181 /* 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
|
1182 to the specification (i.e. max is 111111110xxxxxxxxxxxx). */ |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1183 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1184 b = GET_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1185 b = 31 - av_log2(~b); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1186 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1187 if (b > 8) { |
11833 | 1188 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
|
1189 return -1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1190 } |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1191 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1192 #if MIN_CACHE_BITS < 21 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1193 LAST_SKIP_BITS(re, gb, b + 1); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1194 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1195 #else |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1196 SKIP_BITS(re, gb, b + 1); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1197 #endif |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1198 b += 4; |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1199 n = (1 << b) + SHOW_UBITS(re, gb, b); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1200 LAST_SKIP_BITS(re, gb, b); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1201 *icf++ = cbrt_tab[n] | (bits & 1<<31); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1202 bits <<= 1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1203 } else { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1204 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
|
1205 *icf++ = (bits & 1<<31) | v; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1206 bits <<= !!v; |
9053 | 1207 } |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1208 cb_idx >>= 4; |
9052
54973ad4b7cf
Refactor AAC unsigned band type decoding for a modest speedup.
alexc
parents:
9051
diff
changeset
|
1209 } |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1210 } while (len -= 2); |
10220 | 1211 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1212 ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len); |
7581 | 1213 } |
1214 } | |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1215 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1216 CLOSE_READER(re, gb); |
7581 | 1217 } |
1218 } | |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1219 coef += g_len << 7; |
7581 | 1220 } |
1221 | |
1222 if (pulse_present) { | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1223 idx = 0; |
10004 | 1224 for (i = 0; i < pulse->num_pulse; i++) { |
1225 float co = coef_base[ pulse->pos[i] ]; | |
1226 while (offsets[idx + 1] <= pulse->pos[i]) | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1227 idx++; |
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1228 if (band_type[idx] != NOISE_BT && sf[idx]) { |
7858 | 1229 float ico = -pulse->amp[i]; |
1230 if (co) { | |
1231 co /= sf[idx]; | |
1232 ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico); | |
1233 } | |
1234 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
|
1235 } |
7581 | 1236 } |
1237 } | |
1238 return 0; | |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1239 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1240 err_cb_overflow: |
11833 | 1241 av_log(ac->avctx, AV_LOG_ERROR, |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1242 "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
|
1243 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
|
1244 return -1; |
7581 | 1245 } |
1246 | |
10004 | 1247 static av_always_inline float flt16_round(float pf) |
1248 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1249 union float754 tmp; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1250 tmp.f = pf; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1251 tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1252 return tmp.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1253 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1254 |
10004 | 1255 static av_always_inline float flt16_even(float pf) |
1256 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1257 union float754 tmp; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1258 tmp.f = pf; |
10004 | 1259 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
|
1260 return tmp.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1261 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1262 |
10004 | 1263 static av_always_inline float flt16_trunc(float pf) |
1264 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1265 union float754 pun; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1266 pun.f = pf; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1267 pun.i &= 0xFFFF0000U; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1268 return pun.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1269 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1270 |
11358 | 1271 static av_always_inline void predict(AACContext *ac, PredictorState *ps, float *coef, |
10004 | 1272 int output_enable) |
1273 { | |
1274 const float a = 0.953125; // 61.0 / 64 | |
1275 const float alpha = 0.90625; // 29.0 / 32 | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1276 float e0, e1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1277 float pv; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1278 float k1, k2; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1279 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1280 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
|
1281 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
|
1282 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1283 pv = flt16_round(k1 * ps->r0 + k2 * ps->r1); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1284 if (output_enable) |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1285 *coef += pv * ac->sf_scale; |
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 e0 = *coef / ac->sf_scale; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1288 e1 = e0 - k1 * ps->r0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1289 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1290 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
|
1291 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
|
1292 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
|
1293 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
|
1294 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1295 ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1296 ps->r0 = flt16_trunc(a * e0); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1297 } |
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 /** |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1300 * Apply AAC-Main style frequency domain prediction. |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1301 */ |
10004 | 1302 static void apply_prediction(AACContext *ac, SingleChannelElement *sce) |
1303 { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1304 int sfb, k; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1305 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1306 if (!sce->ics.predictor_initialized) { |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1307 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1308 sce->ics.predictor_initialized = 1; |
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 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1311 if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1312 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
|
1313 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
|
1314 predict(ac, &sce->predictor_state[k], &sce->coeffs[k], |
10004 | 1315 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
|
1316 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1317 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1318 if (sce->ics.predictor_reset_group) |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1319 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
|
1320 } else |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1321 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1322 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1323 |
7581 | 1324 /** |
7539 | 1325 * Decode an individual_channel_stream payload; reference: table 4.44. |
1326 * | |
1327 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
1328 * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.) | |
1329 * | |
1330 * @return Returns error status. 0 - OK, !0 - error | |
1331 */ | |
10004 | 1332 static int decode_ics(AACContext *ac, SingleChannelElement *sce, |
1333 GetBitContext *gb, int common_window, int scale_flag) | |
1334 { | |
7539 | 1335 Pulse pulse; |
10004 | 1336 TemporalNoiseShaping *tns = &sce->tns; |
1337 IndividualChannelStream *ics = &sce->ics; | |
1338 float *out = sce->coeffs; | |
7539 | 1339 int global_gain, pulse_present = 0; |
1340 | |
7580 | 1341 /* This assignment is to silence a GCC warning about the variable being used |
1342 * uninitialized when in fact it always is. | |
7539 | 1343 */ |
1344 pulse.num_pulse = 0; | |
1345 | |
1346 global_gain = get_bits(gb, 8); | |
1347 | |
1348 if (!common_window && !scale_flag) { | |
1349 if (decode_ics_info(ac, ics, gb, 0) < 0) | |
1350 return -1; | |
1351 } | |
1352 | |
1353 if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0) | |
1354 return -1; | |
1355 if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0) | |
1356 return -1; | |
1357 | |
1358 pulse_present = 0; | |
1359 if (!scale_flag) { | |
1360 if ((pulse_present = get_bits1(gb))) { | |
1361 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { | |
11833 | 1362 av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n"); |
7539 | 1363 return -1; |
1364 } | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
1365 if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) { |
11833 | 1366 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
|
1367 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
1368 } |
7539 | 1369 } |
1370 if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics)) | |
1371 return -1; | |
1372 if (get_bits1(gb)) { | |
11833 | 1373 av_log_missing_feature(ac->avctx, "SSR", 1); |
7539 | 1374 return -1; |
1375 } | |
1376 } | |
1377 | |
7580 | 1378 if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0) |
7539 | 1379 return -1; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1380 |
10004 | 1381 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
|
1382 apply_prediction(ac, sce); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1383 |
7539 | 1384 return 0; |
1385 } | |
1386 | |
1387 /** | |
7581 | 1388 * Mid/Side stereo decoding; reference: 4.6.8.1.3. |
1389 */ | |
10220 | 1390 static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe) |
10004 | 1391 { |
1392 const IndividualChannelStream *ics = &cpe->ch[0].ics; | |
7581 | 1393 float *ch0 = cpe->ch[0].coeffs; |
1394 float *ch1 = cpe->ch[1].coeffs; | |
10220 | 1395 int g, i, group, idx = 0; |
10004 | 1396 const uint16_t *offsets = ics->swb_offset; |
7581 | 1397 for (g = 0; g < ics->num_window_groups; g++) { |
1398 for (i = 0; i < ics->max_sfb; i++, idx++) { | |
1399 if (cpe->ms_mask[idx] && | |
10004 | 1400 cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) { |
7581 | 1401 for (group = 0; group < ics->group_len[g]; group++) { |
10220 | 1402 ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i], |
1403 ch1 + group * 128 + offsets[i], | |
1404 offsets[i+1] - offsets[i]); | |
7581 | 1405 } |
1406 } | |
1407 } | |
10004 | 1408 ch0 += ics->group_len[g] * 128; |
1409 ch1 += ics->group_len[g] * 128; | |
7581 | 1410 } |
1411 } | |
1412 | |
1413 /** | |
1414 * intensity stereo decoding; reference: 4.6.8.2.3 | |
1415 * | |
1416 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
1417 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
1418 * [3] reserved for scalable AAC | |
1419 */ | |
10004 | 1420 static void apply_intensity_stereo(ChannelElement *cpe, int ms_present) |
1421 { | |
1422 const IndividualChannelStream *ics = &cpe->ch[1].ics; | |
1423 SingleChannelElement *sce1 = &cpe->ch[1]; | |
7581 | 1424 float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs; |
10004 | 1425 const uint16_t *offsets = ics->swb_offset; |
7581 | 1426 int g, group, i, k, idx = 0; |
1427 int c; | |
1428 float scale; | |
1429 for (g = 0; g < ics->num_window_groups; g++) { | |
1430 for (i = 0; i < ics->max_sfb;) { | |
1431 if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) { | |
1432 const int bt_run_end = sce1->band_type_run_end[idx]; | |
1433 for (; i < bt_run_end; i++, idx++) { | |
1434 c = -1 + 2 * (sce1->band_type[idx] - 14); | |
1435 if (ms_present) | |
1436 c *= 1 - 2 * cpe->ms_mask[idx]; | |
1437 scale = c * sce1->sf[idx]; | |
1438 for (group = 0; group < ics->group_len[g]; group++) | |
10004 | 1439 for (k = offsets[i]; k < offsets[i + 1]; k++) |
1440 coef1[group * 128 + k] = scale * coef0[group * 128 + k]; | |
7581 | 1441 } |
1442 } else { | |
1443 int bt_run_end = sce1->band_type_run_end[idx]; | |
1444 idx += bt_run_end - i; | |
1445 i = bt_run_end; | |
1446 } | |
1447 } | |
10004 | 1448 coef0 += ics->group_len[g] * 128; |
1449 coef1 += ics->group_len[g] * 128; | |
7581 | 1450 } |
1451 } | |
1452 | |
1453 /** | |
7539 | 1454 * Decode a channel_pair_element; reference: table 4.4. |
1455 * | |
1456 * @param elem_id Identifies the instance of a syntax element. | |
1457 * | |
1458 * @return Returns error status. 0 - OK, !0 - error | |
1459 */ | |
10004 | 1460 static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe) |
1461 { | |
7539 | 1462 int i, ret, common_window, ms_present = 0; |
1463 | |
1464 common_window = get_bits1(gb); | |
1465 if (common_window) { | |
1466 if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1)) | |
1467 return -1; | |
1468 i = cpe->ch[1].ics.use_kb_window[0]; | |
1469 cpe->ch[1].ics = cpe->ch[0].ics; | |
1470 cpe->ch[1].ics.use_kb_window[1] = i; | |
1471 ms_present = get_bits(gb, 2); | |
10004 | 1472 if (ms_present == 3) { |
11833 | 1473 av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n"); |
7539 | 1474 return -1; |
10004 | 1475 } else if (ms_present) |
7539 | 1476 decode_mid_side_stereo(cpe, gb, ms_present); |
1477 } | |
1478 if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0))) | |
1479 return ret; | |
1480 if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0))) | |
1481 return ret; | |
1482 | |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1483 if (common_window) { |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1484 if (ms_present) |
10220 | 1485 apply_mid_side_stereo(ac, cpe); |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1486 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
|
1487 apply_prediction(ac, &cpe->ch[0]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1488 apply_prediction(ac, &cpe->ch[1]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1489 } |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1490 } |
7539 | 1491 |
7580 | 1492 apply_intensity_stereo(cpe, ms_present); |
7539 | 1493 return 0; |
1494 } | |
1495 | |
7581 | 1496 /** |
1497 * Decode coupling_channel_element; reference: table 4.8. | |
1498 * | |
1499 * @param elem_id Identifies the instance of a syntax element. | |
1500 * | |
1501 * @return Returns error status. 0 - OK, !0 - error | |
1502 */ | |
10004 | 1503 static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che) |
1504 { | |
7581 | 1505 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
|
1506 int c, g, sfb, ret; |
7581 | 1507 int sign; |
1508 float scale; | |
10004 | 1509 SingleChannelElement *sce = &che->ch[0]; |
1510 ChannelCoupling *coup = &che->coup; | |
7581 | 1511 |
10004 | 1512 coup->coupling_point = 2 * get_bits1(gb); |
7578 | 1513 coup->num_coupled = get_bits(gb, 3); |
1514 for (c = 0; c <= coup->num_coupled; c++) { | |
1515 num_gain++; | |
1516 coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE; | |
1517 coup->id_select[c] = get_bits(gb, 4); | |
1518 if (coup->type[c] == TYPE_CPE) { | |
1519 coup->ch_select[c] = get_bits(gb, 2); | |
1520 if (coup->ch_select[c] == 3) | |
1521 num_gain++; | |
1522 } else | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1523 coup->ch_select[c] = 2; |
7578 | 1524 } |
10004 | 1525 coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1); |
7578 | 1526 |
10004 | 1527 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
|
1528 scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3)); |
7578 | 1529 |
1530 if ((ret = decode_ics(ac, sce, gb, 0, 0))) | |
1531 return ret; | |
1532 | |
1533 for (c = 0; c < num_gain; c++) { | |
10004 | 1534 int idx = 0; |
1535 int cge = 1; | |
7578 | 1536 int gain = 0; |
1537 float gain_cache = 1.; | |
1538 if (c) { | |
1539 cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb); | |
1540 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
|
1541 gain_cache = pow(scale, -gain); |
7578 | 1542 } |
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
|
1543 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
|
1544 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
|
1545 } else { |
8823 | 1546 for (g = 0; g < sce->ics.num_window_groups; g++) { |
1547 for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) { | |
1548 if (sce->band_type[idx] != ZERO_BT) { | |
1549 if (!cge) { | |
1550 int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; | |
10004 | 1551 if (t) { |
8823 | 1552 int s = 1; |
1553 t = gain += t; | |
1554 if (sign) { | |
1555 s -= 2 * (t & 0x1); | |
1556 t >>= 1; | |
1557 } | |
1558 gain_cache = pow(scale, -t) * s; | |
7578 | 1559 } |
1560 } | |
8823 | 1561 coup->gain[c][idx] = gain_cache; |
7578 | 1562 } |
1563 } | |
7890 | 1564 } |
1565 } | |
7578 | 1566 } |
1567 return 0; | |
1568 } | |
1569 | |
7539 | 1570 /** |
7578 | 1571 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53. |
1572 * | |
1573 * @return Returns number of bytes consumed. | |
1574 */ | |
10004 | 1575 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, |
1576 GetBitContext *gb) | |
1577 { | |
7578 | 1578 int i; |
1579 int num_excl_chan = 0; | |
1580 | |
1581 do { | |
1582 for (i = 0; i < 7; i++) | |
1583 che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb); | |
1584 } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb)); | |
1585 | |
1586 return num_excl_chan / 7; | |
1587 } | |
1588 | |
1589 /** | |
7539 | 1590 * Decode dynamic range information; reference: table 4.52. |
1591 * | |
1592 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1593 * | |
1594 * @return Returns number of bytes consumed. | |
1595 */ | |
10004 | 1596 static int decode_dynamic_range(DynamicRangeControl *che_drc, |
1597 GetBitContext *gb, int cnt) | |
1598 { | |
1599 int n = 1; | |
7539 | 1600 int drc_num_bands = 1; |
1601 int i; | |
1602 | |
1603 /* pce_tag_present? */ | |
10004 | 1604 if (get_bits1(gb)) { |
7539 | 1605 che_drc->pce_instance_tag = get_bits(gb, 4); |
1606 skip_bits(gb, 4); // tag_reserved_bits | |
1607 n++; | |
1608 } | |
1609 | |
1610 /* excluded_chns_present? */ | |
10004 | 1611 if (get_bits1(gb)) { |
7539 | 1612 n += decode_drc_channel_exclusions(che_drc, gb); |
1613 } | |
1614 | |
1615 /* drc_bands_present? */ | |
1616 if (get_bits1(gb)) { | |
1617 che_drc->band_incr = get_bits(gb, 4); | |
1618 che_drc->interpolation_scheme = get_bits(gb, 4); | |
1619 n++; | |
1620 drc_num_bands += che_drc->band_incr; | |
1621 for (i = 0; i < drc_num_bands; i++) { | |
1622 che_drc->band_top[i] = get_bits(gb, 8); | |
1623 n++; | |
1624 } | |
1625 } | |
1626 | |
1627 /* prog_ref_level_present? */ | |
1628 if (get_bits1(gb)) { | |
1629 che_drc->prog_ref_level = get_bits(gb, 7); | |
1630 skip_bits1(gb); // prog_ref_level_reserved_bits | |
1631 n++; | |
1632 } | |
1633 | |
1634 for (i = 0; i < drc_num_bands; i++) { | |
1635 che_drc->dyn_rng_sgn[i] = get_bits1(gb); | |
1636 che_drc->dyn_rng_ctl[i] = get_bits(gb, 7); | |
1637 n++; | |
1638 } | |
1639 | |
1640 return n; | |
1641 } | |
1642 | |
1643 /** | |
1644 * Decode extension data (incomplete); reference: table 4.51. | |
1645 * | |
1646 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1647 * | |
1648 * @return Returns number of bytes consumed | |
1649 */ | |
11401 | 1650 static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt, |
1651 ChannelElement *che, enum RawDataBlockType elem_type) | |
10004 | 1652 { |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1653 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
|
1654 int res = cnt; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1655 switch (get_bits(gb, 4)) { // extension type |
10004 | 1656 case EXT_SBR_DATA_CRC: |
1657 crc_flag++; | |
1658 case EXT_SBR_DATA: | |
11401 | 1659 if (!che) { |
11833 | 1660 av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n"); |
11401 | 1661 return res; |
1662 } else if (!ac->m4ac.sbr) { | |
11833 | 1663 av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n"); |
11401 | 1664 skip_bits_long(gb, 8 * cnt - 4); |
1665 return res; | |
1666 } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) { | |
11833 | 1667 av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n"); |
11401 | 1668 skip_bits_long(gb, 8 * cnt - 4); |
1669 return res; | |
11886 | 1670 } else if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) { |
1671 ac->m4ac.sbr = 1; | |
1672 ac->m4ac.ps = 1; | |
1673 output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured); | |
11401 | 1674 } else { |
1675 ac->m4ac.sbr = 1; | |
1676 } | |
1677 res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type); | |
10004 | 1678 break; |
1679 case EXT_DYNAMIC_RANGE: | |
1680 res = decode_dynamic_range(&ac->che_drc, gb, cnt); | |
1681 break; | |
1682 case EXT_FILL: | |
1683 case EXT_FILL_DATA: | |
1684 case EXT_DATA_ELEMENT: | |
1685 default: | |
1686 skip_bits_long(gb, 8 * cnt - 4); | |
1687 break; | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1688 }; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1689 return res; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1690 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1691 |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1692 /** |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1693 * 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
|
1694 * |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1695 * @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
|
1696 * @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
|
1697 */ |
10004 | 1698 static void apply_tns(float coef[1024], TemporalNoiseShaping *tns, |
1699 IndividualChannelStream *ics, int decode) | |
1700 { | |
1701 const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb); | |
7636 | 1702 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
|
1703 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
|
1704 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
|
1705 |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1706 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
|
1707 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
|
1708 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
|
1709 top = bottom; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1710 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
|
1711 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
|
1712 if (order == 0) |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1713 continue; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1714 |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1715 // tns_decode_coef |
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1716 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
|
1717 |
7609 | 1718 start = ics->swb_offset[FFMIN(bottom, mmm)]; |
1719 end = ics->swb_offset[FFMIN( top, mmm)]; | |
1720 if ((size = end - start) <= 0) | |
1721 continue; | |
1722 if (tns->direction[w][filt]) { | |
10004 | 1723 inc = -1; |
1724 start = end - 1; | |
7609 | 1725 } else { |
1726 inc = 1; | |
1727 } | |
1728 start += w * 128; | |
1729 | |
1730 // ar filter | |
1731 for (m = 0; m < size; m++, start += inc) | |
1732 for (i = 1; i <= FFMIN(m, order); i++) | |
10004 | 1733 coef[start] -= coef[start - i * inc] * lpc[i - 1]; |
7609 | 1734 } |
1735 } | |
1736 } | |
1737 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1738 /** |
7539 | 1739 * Conduct IMDCT and windowing. |
1740 */ | |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1741 static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce, float bias) |
10004 | 1742 { |
1743 IndividualChannelStream *ics = &sce->ics; | |
1744 float *in = sce->coeffs; | |
1745 float *out = sce->ret; | |
1746 float *saved = sce->saved; | |
1747 const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; | |
1748 const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; | |
1749 const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; | |
1750 float *buf = ac->buf_mdct; | |
1751 float *temp = ac->temp; | |
7539 | 1752 int i; |
1753 | |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1754 // imdct |
7578 | 1755 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { |
1756 if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) | |
11833 | 1757 av_log(ac->avctx, AV_LOG_WARNING, |
7578 | 1758 "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. " |
1759 "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
|
1760 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
|
1761 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
|
1762 } else |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1763 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
|
1764 |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1765 /* window overlapping |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1766 * 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
|
1767 * 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
|
1768 * 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
|
1769 * 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
|
1770 */ |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1771 if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) && |
10004 | 1772 (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
|
1773 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
|
1774 } else { |
7662 | 1775 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
|
1776 out[i] = saved[i] + bias; |
7578 | 1777 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1778 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
|
1779 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
|
1780 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
|
1781 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
|
1782 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
|
1783 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
|
1784 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
|
1785 } else { |
11481
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, saved + 448, buf, swindow_prev, bias, 64); |
7662 | 1787 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
|
1788 out[i] = buf[i-512] + bias; |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1789 } |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1790 } |
7578 | 1791 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1792 // buffer update |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1793 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
|
1794 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
|
1795 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
|
1796 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
|
1797 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
|
1798 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
|
1799 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
|
1800 } 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
|
1801 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
|
1802 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
|
1803 } 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
|
1804 memcpy( saved, buf + 512, 512 * sizeof(float)); |
7578 | 1805 } |
1806 } | |
1807 | |
7539 | 1808 /** |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1809 * 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
|
1810 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1811 * @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
|
1812 */ |
10004 | 1813 static void apply_dependent_coupling(AACContext *ac, |
1814 SingleChannelElement *target, | |
1815 ChannelElement *cce, int index) | |
1816 { | |
1817 IndividualChannelStream *ics = &cce->ch[0].ics; | |
1818 const uint16_t *offsets = ics->swb_offset; | |
1819 float *dest = target->coeffs; | |
1820 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
|
1821 int g, i, group, k, idx = 0; |
10004 | 1822 if (ac->m4ac.object_type == AOT_AAC_LTP) { |
11833 | 1823 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
|
1824 "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
|
1825 return; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1826 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1827 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
|
1828 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
|
1829 if (cce->ch[0].band_type[idx] != ZERO_BT) { |
9143 | 1830 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
|
1831 for (group = 0; group < ics->group_len[g]; group++) { |
10004 | 1832 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
|
1833 // XXX dsputil-ize |
10004 | 1834 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
|
1835 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1836 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1837 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1838 } |
10004 | 1839 dest += ics->group_len[g] * 128; |
1840 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
|
1841 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1842 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1843 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1844 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1845 * 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
|
1846 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1847 * @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
|
1848 */ |
10004 | 1849 static void apply_independent_coupling(AACContext *ac, |
1850 SingleChannelElement *target, | |
1851 ChannelElement *cce, int index) | |
1852 { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1853 int i; |
9051
0cffed11ee33
Use const to better allow the compiler to optimize AAC independent coupling.
alexc
parents:
8823
diff
changeset
|
1854 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
|
1855 const float bias = ac->add_bias; |
10004 | 1856 const float *src = cce->ch[0].ret; |
1857 float *dest = target->ret; | |
11401 | 1858 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
|
1859 |
11401 | 1860 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
|
1861 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
|
1862 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1863 |
7581 | 1864 /** |
1865 * channel coupling transformation interface | |
1866 * | |
1867 * @param index index into coupling gain array | |
1868 * @param apply_coupling_method pointer to (in)dependent coupling function | |
1869 */ | |
10004 | 1870 static void apply_channel_coupling(AACContext *ac, ChannelElement *cc, |
1871 enum RawDataBlockType type, int elem_id, | |
1872 enum CouplingPoint coupling_point, | |
1873 void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)) | |
7581 | 1874 { |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1875 int i, c; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1876 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1877 for (i = 0; i < MAX_ELEM_ID; i++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1878 ChannelElement *cce = ac->che[TYPE_CCE][i]; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1879 int index = 0; |
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 if (cce && cce->coup.coupling_point == coupling_point) { |
10004 | 1882 ChannelCoupling *coup = &cce->coup; |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1883 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1884 for (c = 0; c <= coup->num_coupled; c++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1885 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
|
1886 if (coup->ch_select[c] != 1) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1887 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
|
1888 if (coup->ch_select[c] != 0) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1889 index++; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1890 } |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1891 if (coup->ch_select[c] != 2) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1892 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
|
1893 } else |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1894 index += 1 + (coup->ch_select[c] == 3); |
7581 | 1895 } |
1896 } | |
1897 } | |
1898 } | |
1899 | |
1900 /** | |
1901 * Convert spectral data to float samples, applying all supported tools as appropriate. | |
1902 */ | |
10004 | 1903 static void spectral_to_sample(AACContext *ac) |
1904 { | |
10688 | 1905 int i, type; |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1906 float imdct_bias = (ac->m4ac.sbr <= 0) ? ac->add_bias : 0.0f; |
10688 | 1907 for (type = 3; type >= 0; type--) { |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1908 for (i = 0; i < MAX_ELEM_ID; i++) { |
7581 | 1909 ChannelElement *che = ac->che[type][i]; |
10004 | 1910 if (che) { |
1911 if (type <= TYPE_CPE) | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1912 apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling); |
10004 | 1913 if (che->ch[0].tns.present) |
7581 | 1914 apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1); |
10004 | 1915 if (che->ch[1].tns.present) |
7581 | 1916 apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1); |
10004 | 1917 if (type <= TYPE_CPE) |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1918 apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling); |
11401 | 1919 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
|
1920 imdct_and_windowing(ac, &che->ch[0], imdct_bias); |
11668 | 1921 if (type == TYPE_CPE) { |
1922 imdct_and_windowing(ac, &che->ch[1], imdct_bias); | |
1923 } | |
11667
6818ea5a25a2
Rewrite ff_sbr_apply in a manner more friendly to PS.
alexc
parents:
11644
diff
changeset
|
1924 if (ac->m4ac.sbr > 0) { |
6818ea5a25a2
Rewrite ff_sbr_apply in a manner more friendly to PS.
alexc
parents:
11644
diff
changeset
|
1925 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
|
1926 } |
11401 | 1927 } |
10004 | 1928 if (type <= TYPE_CCE) |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1929 apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling); |
7578 | 1930 } |
1931 } | |
1932 } | |
1933 } | |
1934 | |
10004 | 1935 static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb) |
1936 { | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1937 int size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1938 AACADTSHeaderInfo hdr_info; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1939 |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1940 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
|
1941 if (size > 0) { |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1942 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
|
1943 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
|
1944 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
|
1945 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
|
1946 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
|
1947 return -7; |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1948 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
|
1949 return -7; |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1950 } 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
|
1951 ac->output_configured = OC_NONE; |
9948
98fd723f72e7
Ignore subsequent channel configurations after the first in an AAC file. The
alexc
parents:
9891
diff
changeset
|
1952 } |
11886 | 1953 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
|
1954 ac->m4ac.sbr = -1; |
11886 | 1955 ac->m4ac.ps = -1; |
1956 } | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1957 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
|
1958 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
|
1959 ac->m4ac.object_type = hdr_info.object_type; |
11833 | 1960 if (!ac->avctx->sample_rate) |
1961 ac->avctx->sample_rate = hdr_info.sample_rate; | |
9151 | 1962 if (hdr_info.num_aac_frames == 1) { |
1963 if (!hdr_info.crc_absent) | |
1964 skip_bits(gb, 16); | |
1965 } else { | |
11833 | 1966 av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame is", 0); |
9151 | 1967 return -1; |
1968 } | |
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
|
1969 } |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1970 return size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1971 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1972 |
11833 | 1973 static int aac_decode_frame(AVCodecContext *avctx, void *data, |
10004 | 1974 int *data_size, AVPacket *avpkt) |
1975 { | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9251
diff
changeset
|
1976 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9251
diff
changeset
|
1977 int buf_size = avpkt->size; |
11833 | 1978 AACContext *ac = avctx->priv_data; |
11401 | 1979 ChannelElement *che = NULL, *che_prev = NULL; |
7578 | 1980 GetBitContext gb; |
11401 | 1981 enum RawDataBlockType elem_type, elem_type_prev = TYPE_END; |
7578 | 1982 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
|
1983 int buf_consumed; |
11902 | 1984 int samples = 0, multiplier; |
11746
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
1985 int buf_offset; |
7578 | 1986 |
10004 | 1987 init_get_bits(&gb, buf, buf_size * 8); |
7578 | 1988 |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1989 if (show_bits(&gb, 12) == 0xfff) { |
9510 | 1990 if (parse_adts_frame_header(ac, &gb) < 0) { |
11833 | 1991 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
|
1992 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1993 } |
8812 | 1994 if (ac->m4ac.sampling_index > 12) { |
11833 | 1995 av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); |
8789 | 1996 return -1; |
1997 } | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1998 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1999 |
11819
9bdc0fe882fa
aacdec: Work around illegal files with all elem_id tags set to the same value.
alexc
parents:
11787
diff
changeset
|
2000 memset(ac->tags_seen_this_frame, 0, sizeof(ac->tags_seen_this_frame)); |
7578 | 2001 // parse |
2002 while ((elem_type = get_bits(&gb, 3)) != TYPE_END) { | |
2003 elem_id = get_bits(&gb, 4); | |
2004 | |
11903 | 2005 if (elem_type < TYPE_DSE) { |
11904 | 2006 if (!(che=get_che(ac, elem_type, elem_id))) { |
2007 av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", | |
2008 elem_type, elem_id); | |
2009 return -1; | |
2010 } | |
11902 | 2011 samples = 1024; |
11903 | 2012 } |
11902 | 2013 |
7578 | 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 | |
11902 | 2096 if (samples) |
11905 | 2097 ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels); |
7539 | 2098 |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2099 if (ac->output_configured) |
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2100 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
|
2101 |
11362
1682a19a0881
AAC: Return the number of bytes consumed in decoding a frame.
alexc
parents:
11358
diff
changeset
|
2102 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
|
2103 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
|
2104 if (buf[buf_offset]) |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2105 break; |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2106 |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2107 return buf_size > buf_offset ? buf_consumed : buf_size; |
7539 | 2108 } |
2109 | |
11833 | 2110 static av_cold int aac_decode_close(AVCodecContext *avctx) |
10004 | 2111 { |
11833 | 2112 AACContext *ac = avctx->priv_data; |
7540 | 2113 int i, type; |
7501 | 2114 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
2115 for (i = 0; i < MAX_ELEM_ID; i++) { |
11401 | 2116 for (type = 0; type < 4; type++) { |
2117 if (ac->che[type][i]) | |
2118 ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr); | |
7540 | 2119 av_freep(&ac->che[type][i]); |
11401 | 2120 } |
7501 | 2121 } |
2122 | |
2123 ff_mdct_end(&ac->mdct); | |
2124 ff_mdct_end(&ac->mdct_small); | |
10004 | 2125 return 0; |
7501 | 2126 } |
2127 | |
2128 AVCodec aac_decoder = { | |
2129 "aac", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11489
diff
changeset
|
2130 AVMEDIA_TYPE_AUDIO, |
7501 | 2131 CODEC_ID_AAC, |
2132 sizeof(AACContext), | |
2133 aac_decode_init, | |
2134 NULL, | |
2135 aac_decode_close, | |
2136 aac_decode_frame, | |
2137 .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
|
2138 .sample_fmts = (const enum SampleFormat[]) { |
10004 | 2139 SAMPLE_FMT_S16,SAMPLE_FMT_NONE |
2140 }, | |
10306
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
2141 .channel_layouts = aac_channel_layout, |
7501 | 2142 }; |