Mercurial > libavcodec.hg
annotate aacdec.c @ 12197:fbf4d5b1b664 libavcodec
Remove FF_MM_SSE2/3 flags for CPUs where this is generally not faster than
regular MMX code. Examples of this are the Core1 CPU. Instead, set a new flag,
FF_MM_SSE2/3SLOW, which can be checked for particular SSE2/3 functions that
have been checked specifically on such CPUs and are actually faster than
their MMX counterparts.
In addition, use this flag to enable particular VP8 and LPC SSE2 functions
that are faster than their MMX counterparts.
Based on a patch by Loren Merritt <lorenm AT u washington edu>.
author | rbultje |
---|---|
date | Mon, 19 Jul 2010 22:38:23 +0000 |
parents | 7f8b11d9c831 |
children | 97db3c60fb9c |
rev | line source |
---|---|
7501 | 1 /* |
2 * AAC decoder | |
3 * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org ) | |
4 * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com ) | |
5 * | |
6 * This file is part of FFmpeg. | |
7 * | |
8 * FFmpeg is free software; you can redistribute it and/or | |
9 * modify it under the terms of the GNU Lesser General Public | |
10 * License as published by the Free Software Foundation; either | |
11 * version 2.1 of the License, or (at your option) any later version. | |
12 * | |
13 * FFmpeg is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
19 * License along with FFmpeg; if not, write to the Free Software | |
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
21 */ | |
22 | |
23 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
24 * @file |
7501 | 25 * AAC decoder |
26 * @author Oded Shimon ( ods15 ods15 dyndns org ) | |
27 * @author Maxim Gavrilov ( maxim.gavrilov gmail com ) | |
28 */ | |
29 | |
30 /* | |
31 * supported tools | |
32 * | |
33 * Support? Name | |
34 * N (code in SoC repo) gain control | |
35 * Y block switching | |
36 * Y window shapes - standard | |
37 * N window shapes - Low Delay | |
38 * Y filterbank - standard | |
39 * N (code in SoC repo) filterbank - Scalable Sample Rate | |
40 * Y Temporal Noise Shaping | |
41 * N (code in SoC repo) Long Term Prediction | |
42 * Y intensity stereo | |
43 * Y channel coupling | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
44 * Y frequency domain prediction |
7501 | 45 * Y Perceptual Noise Substitution |
46 * Y Mid/Side stereo | |
47 * N Scalable Inverse AAC Quantization | |
48 * N Frequency Selective Switch | |
49 * N upsampling filter | |
50 * Y quantization & coding - AAC | |
51 * N quantization & coding - TwinVQ | |
52 * N quantization & coding - BSAC | |
53 * N AAC Error Resilience tools | |
54 * N Error Resilience payload syntax | |
55 * N Error Protection tool | |
56 * N CELP | |
57 * N Silence Compression | |
58 * N HVXC | |
59 * N HVXC 4kbits/s VR | |
60 * N Structured Audio tools | |
61 * N Structured Audio Sample Bank Format | |
62 * N MIDI | |
63 * N Harmonic and Individual Lines plus Noise | |
64 * N Text-To-Speech Interface | |
11401 | 65 * Y Spectral Band Replication |
7501 | 66 * Y (not in this code) Layer-1 |
67 * Y (not in this code) Layer-2 | |
68 * Y (not in this code) Layer-3 | |
69 * N SinuSoidal Coding (Transient, Sinusoid, Noise) | |
11886 | 70 * Y Parametric Stereo |
7501 | 71 * N Direct Stream Transfer |
72 * | |
73 * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication. | |
74 * - HE AAC v2 comprises LC AAC with Spectral Band Replication and | |
75 Parametric Stereo. | |
76 */ | |
77 | |
78 | |
79 #include "avcodec.h" | |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8200
diff
changeset
|
80 #include "internal.h" |
9428 | 81 #include "get_bits.h" |
7501 | 82 #include "dsputil.h" |
11370 | 83 #include "fft.h" |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
84 #include "lpc.h" |
7501 | 85 |
86 #include "aac.h" | |
87 #include "aactab.h" | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
88 #include "aacdectab.h" |
11489
1aba21918874
Allow hard-coding of the 32kB cubic-root table for AAC.
reimar
parents:
11481
diff
changeset
|
89 #include "cbrt_tablegen.h" |
11401 | 90 #include "sbr.h" |
91 #include "aacsbr.h" | |
7501 | 92 #include "mpeg4audio.h" |
12149
e7634f1b6100
Split the ADTS header decoder off of the ADTS parser.
alexc
parents:
12148
diff
changeset
|
93 #include "aacadtsdec.h" |
7501 | 94 |
95 #include <assert.h> | |
96 #include <errno.h> | |
97 #include <math.h> | |
98 #include <string.h> | |
99 | |
10881 | 100 #if ARCH_ARM |
101 # include "arm/aac.h" | |
102 #endif | |
103 | |
10004 | 104 union float754 { |
105 float f; | |
106 uint32_t i; | |
107 }; | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
108 |
7501 | 109 static VLC vlc_scalefactors; |
110 static VLC vlc_spectral[11]; | |
111 | |
11205 | 112 static const char overread_err[] = "Input buffer exhausted before END element found\n"; |
113 | |
10004 | 114 static ChannelElement *get_che(AACContext *ac, int type, int elem_id) |
115 { | |
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; |
998 | |
999 for (g = 0; g < ics->num_windows; g++) | |
10004 | 1000 memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb])); |
7581 | 1001 |
1002 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
|
1003 unsigned g_len = ics->group_len[g]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1004 |
7581 | 1005 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
|
1006 const unsigned cbt_m1 = band_type[idx] - 1; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1007 float *cfo = coef + offsets[i]; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1008 int off_len = offsets[i + 1] - offsets[i]; |
7581 | 1009 int group; |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1010 |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1011 if (cbt_m1 >= INTENSITY_BT2 - 1) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1012 for (group = 0; group < g_len; group++, cfo+=128) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1013 memset(cfo, 0, off_len * sizeof(float)); |
7581 | 1014 } |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1015 } else if (cbt_m1 == NOISE_BT - 1) { |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1016 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
|
1017 float scale; |
10252 | 1018 float band_energy; |
10220 | 1019 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1020 for (k = 0; k < off_len; k++) { |
7581 | 1021 ac->random_state = lcg_random(ac->random_state); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1022 cfo[k] = ac->random_state; |
8109
7baa25290231
Fix perceptual noise shaping scaling including an oversight of the offset for
superdump
parents:
8042
diff
changeset
|
1023 } |
10220 | 1024 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1025 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
|
1026 scale = sf[idx] / sqrtf(band_energy); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1027 ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len); |
7581 | 1028 } |
10004 | 1029 } else { |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1030 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
|
1031 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
|
1032 VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1033 OPEN_READER(re, gb); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1034 |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1035 switch (cbt_m1 >> 1) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1036 case 0: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1037 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
|
1038 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1039 int len = off_len; |
10220 | 1040 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1041 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1042 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1043 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1044 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1045 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1046 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1047 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1048 cf = VMUL4(cf, vq, cb_idx, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1049 } while (len -= 4); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1050 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1051 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1052 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1053 case 1: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1054 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
|
1055 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1056 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1057 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1058 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1059 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1060 unsigned nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1061 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1062 uint32_t bits; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1063 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1064 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1065 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1066 #if MIN_CACHE_BITS < 20 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1067 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1068 #endif |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1069 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1070 nnz = cb_idx >> 8 & 15; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1071 bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1072 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1073 cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1074 } while (len -= 4); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1075 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1076 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1077 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1078 case 2: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1079 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
|
1080 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1081 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1082 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1083 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1084 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1085 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1086 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1087 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1088 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1089 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1090 cf = VMUL2(cf, vq, cb_idx, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1091 } while (len -= 2); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1092 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1093 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1094 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1095 case 3: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1096 case 4: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1097 for (group = 0; group < g_len; group++, cfo+=128) { |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1098 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1099 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1100 |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1101 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1102 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1103 unsigned nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1104 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1105 unsigned sign; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1106 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1107 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1108 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
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 nnz = cb_idx >> 8 & 15; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1111 sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1112 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1113 cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx); |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1114 } while (len -= 2); |
10876
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1115 } |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1116 break; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1117 |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1118 default: |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1119 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
|
1120 float *cf = cfo; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1121 uint32_t *icf = (uint32_t *) cf; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1122 int len = off_len; |
03d8758218d2
AAC: Unswitch loop over window groups in decode_spectrum_and_dequant()
mru
parents:
10875
diff
changeset
|
1123 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1124 do { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1125 int code; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1126 unsigned nzt, nnz; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1127 unsigned cb_idx; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1128 uint32_t bits; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1129 int j; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1130 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1131 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1132 GET_VLC(code, re, gb, vlc_tab, 8, 2); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1133 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1134 if (!code) { |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1135 *icf++ = 0; |
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1136 *icf++ = 0; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1137 continue; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1138 } |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1139 |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1140 cb_idx = cb_vector_idx[code]; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1141 nnz = cb_idx >> 12; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1142 nzt = cb_idx >> 8; |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1143 bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1144 LAST_SKIP_BITS(re, gb, nnz); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1145 |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1146 for (j = 0; j < 2; j++) { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1147 if (nzt & 1<<j) { |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1148 uint32_t b; |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1149 int n; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1150 /* 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
|
1151 to the specification (i.e. max is 111111110xxxxxxxxxxxx). */ |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1152 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1153 b = GET_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1154 b = 31 - av_log2(~b); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1155 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1156 if (b > 8) { |
11833 | 1157 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
|
1158 return -1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1159 } |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1160 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1161 #if MIN_CACHE_BITS < 21 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1162 LAST_SKIP_BITS(re, gb, b + 1); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1163 UPDATE_CACHE(re, gb); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1164 #else |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1165 SKIP_BITS(re, gb, b + 1); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1166 #endif |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1167 b += 4; |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1168 n = (1 << b) + SHOW_UBITS(re, gb, b); |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1169 LAST_SKIP_BITS(re, gb, b); |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1170 *icf++ = cbrt_tab[n] | (bits & 1<<31); |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1171 bits <<= 1; |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1172 } else { |
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1173 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
|
1174 *icf++ = (bits & 1<<31) | v; |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1175 bits <<= !!v; |
9053 | 1176 } |
10874
bcfe2acbf190
AAC: Compress codebook tables and optimise sign bit handling
mru
parents:
10849
diff
changeset
|
1177 cb_idx >>= 4; |
9052
54973ad4b7cf
Refactor AAC unsigned band type decoding for a modest speedup.
alexc
parents:
9051
diff
changeset
|
1178 } |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1179 } while (len -= 2); |
10220 | 1180 |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1181 ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len); |
7581 | 1182 } |
1183 } | |
10886
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1184 |
966a8afdd9aa
AAC: optimise bitstream reading in decode_spectrum_and_dequant()
mru
parents:
10881
diff
changeset
|
1185 CLOSE_READER(re, gb); |
7581 | 1186 } |
1187 } | |
10875
6a6a1c2d8745
AAC: simplify some calculations in decode_spectrum_and_dequant()
mru
parents:
10874
diff
changeset
|
1188 coef += g_len << 7; |
7581 | 1189 } |
1190 | |
1191 if (pulse_present) { | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1192 idx = 0; |
10004 | 1193 for (i = 0; i < pulse->num_pulse; i++) { |
1194 float co = coef_base[ pulse->pos[i] ]; | |
1195 while (offsets[idx + 1] <= pulse->pos[i]) | |
7857
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1196 idx++; |
d7801471cd52
Apply pulses to unscaled coefficients rather than scaled.
superdump
parents:
7856
diff
changeset
|
1197 if (band_type[idx] != NOISE_BT && sf[idx]) { |
7858 | 1198 float ico = -pulse->amp[i]; |
1199 if (co) { | |
1200 co /= sf[idx]; | |
1201 ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico); | |
1202 } | |
1203 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
|
1204 } |
7581 | 1205 } |
1206 } | |
1207 return 0; | |
1208 } | |
1209 | |
10004 | 1210 static av_always_inline float flt16_round(float pf) |
1211 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1212 union float754 tmp; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1213 tmp.f = pf; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1214 tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1215 return tmp.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1216 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1217 |
10004 | 1218 static av_always_inline float flt16_even(float pf) |
1219 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1220 union float754 tmp; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1221 tmp.f = pf; |
10004 | 1222 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
|
1223 return tmp.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1224 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1225 |
10004 | 1226 static av_always_inline float flt16_trunc(float pf) |
1227 { | |
9179
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1228 union float754 pun; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1229 pun.f = pf; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1230 pun.i &= 0xFFFF0000U; |
4172c9ef331a
AAC: IEEE-754 type punning for 16-bit floating point rounding.
alexc
parents:
9151
diff
changeset
|
1231 return pun.f; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1232 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1233 |
11358 | 1234 static av_always_inline void predict(AACContext *ac, PredictorState *ps, float *coef, |
10004 | 1235 int output_enable) |
1236 { | |
1237 const float a = 0.953125; // 61.0 / 64 | |
1238 const float alpha = 0.90625; // 29.0 / 32 | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1239 float e0, e1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1240 float pv; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1241 float k1, k2; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1242 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1243 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
|
1244 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
|
1245 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1246 pv = flt16_round(k1 * ps->r0 + k2 * ps->r1); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1247 if (output_enable) |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1248 *coef += pv * ac->sf_scale; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1249 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1250 e0 = *coef / ac->sf_scale; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1251 e1 = e0 - k1 * ps->r0; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1252 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1253 ps->cor1 = flt16_trunc(alpha * ps->cor1 + ps->r1 * e1); |
12155
7f8b11d9c831
aacdec: Eliminate the use of doubles in the MAIN predictor.
alexc
parents:
12154
diff
changeset
|
1254 ps->var1 = flt16_trunc(alpha * ps->var1 + 0.5f * (ps->r1 * ps->r1 + e1 * e1)); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1255 ps->cor0 = flt16_trunc(alpha * ps->cor0 + ps->r0 * e0); |
12155
7f8b11d9c831
aacdec: Eliminate the use of doubles in the MAIN predictor.
alexc
parents:
12154
diff
changeset
|
1256 ps->var0 = flt16_trunc(alpha * ps->var0 + 0.5f * (ps->r0 * ps->r0 + e0 * e0)); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1257 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1258 ps->r1 = flt16_trunc(a * (ps->r0 - k1 * e0)); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1259 ps->r0 = flt16_trunc(a * e0); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1260 } |
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 /** |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1263 * Apply AAC-Main style frequency domain prediction. |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1264 */ |
10004 | 1265 static void apply_prediction(AACContext *ac, SingleChannelElement *sce) |
1266 { | |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1267 int sfb, k; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1268 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1269 if (!sce->ics.predictor_initialized) { |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1270 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1271 sce->ics.predictor_initialized = 1; |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1272 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1273 |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1274 if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) { |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1275 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
|
1276 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
|
1277 predict(ac, &sce->predictor_state[k], &sce->coeffs[k], |
10004 | 1278 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
|
1279 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1280 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1281 if (sce->ics.predictor_reset_group) |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1282 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
|
1283 } else |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1284 reset_all_predictors(sce->predictor_state); |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1285 } |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1286 |
7581 | 1287 /** |
7539 | 1288 * Decode an individual_channel_stream payload; reference: table 4.44. |
1289 * | |
1290 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. | |
1291 * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.) | |
1292 * | |
1293 * @return Returns error status. 0 - OK, !0 - error | |
1294 */ | |
10004 | 1295 static int decode_ics(AACContext *ac, SingleChannelElement *sce, |
1296 GetBitContext *gb, int common_window, int scale_flag) | |
1297 { | |
7539 | 1298 Pulse pulse; |
10004 | 1299 TemporalNoiseShaping *tns = &sce->tns; |
1300 IndividualChannelStream *ics = &sce->ics; | |
1301 float *out = sce->coeffs; | |
7539 | 1302 int global_gain, pulse_present = 0; |
1303 | |
7580 | 1304 /* This assignment is to silence a GCC warning about the variable being used |
1305 * uninitialized when in fact it always is. | |
7539 | 1306 */ |
1307 pulse.num_pulse = 0; | |
1308 | |
1309 global_gain = get_bits(gb, 8); | |
1310 | |
1311 if (!common_window && !scale_flag) { | |
1312 if (decode_ics_info(ac, ics, gb, 0) < 0) | |
1313 return -1; | |
1314 } | |
1315 | |
1316 if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0) | |
1317 return -1; | |
1318 if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0) | |
1319 return -1; | |
1320 | |
1321 pulse_present = 0; | |
1322 if (!scale_flag) { | |
1323 if ((pulse_present = get_bits1(gb))) { | |
1324 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { | |
11833 | 1325 av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n"); |
7539 | 1326 return -1; |
1327 } | |
7871
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
1328 if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) { |
11833 | 1329 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
|
1330 return -1; |
8277c41b7160
Validate pulse position and error out if an invalid position is encountered.
superdump
parents:
7858
diff
changeset
|
1331 } |
7539 | 1332 } |
1333 if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics)) | |
1334 return -1; | |
1335 if (get_bits1(gb)) { | |
11833 | 1336 av_log_missing_feature(ac->avctx, "SSR", 1); |
7539 | 1337 return -1; |
1338 } | |
1339 } | |
1340 | |
7580 | 1341 if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0) |
7539 | 1342 return -1; |
8199
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1343 |
10004 | 1344 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
|
1345 apply_prediction(ac, sce); |
8a8d40fe77d9
AAC: Frequency domain prediction and hence Main profile support
superdump
parents:
8109
diff
changeset
|
1346 |
7539 | 1347 return 0; |
1348 } | |
1349 | |
1350 /** | |
7581 | 1351 * Mid/Side stereo decoding; reference: 4.6.8.1.3. |
1352 */ | |
10220 | 1353 static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe) |
10004 | 1354 { |
1355 const IndividualChannelStream *ics = &cpe->ch[0].ics; | |
7581 | 1356 float *ch0 = cpe->ch[0].coeffs; |
1357 float *ch1 = cpe->ch[1].coeffs; | |
10220 | 1358 int g, i, group, idx = 0; |
10004 | 1359 const uint16_t *offsets = ics->swb_offset; |
7581 | 1360 for (g = 0; g < ics->num_window_groups; g++) { |
1361 for (i = 0; i < ics->max_sfb; i++, idx++) { | |
1362 if (cpe->ms_mask[idx] && | |
10004 | 1363 cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) { |
7581 | 1364 for (group = 0; group < ics->group_len[g]; group++) { |
10220 | 1365 ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i], |
1366 ch1 + group * 128 + offsets[i], | |
1367 offsets[i+1] - offsets[i]); | |
7581 | 1368 } |
1369 } | |
1370 } | |
10004 | 1371 ch0 += ics->group_len[g] * 128; |
1372 ch1 += ics->group_len[g] * 128; | |
7581 | 1373 } |
1374 } | |
1375 | |
1376 /** | |
1377 * intensity stereo decoding; reference: 4.6.8.2.3 | |
1378 * | |
1379 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s; | |
1380 * [1] mask is decoded from bitstream; [2] mask is all 1s; | |
1381 * [3] reserved for scalable AAC | |
1382 */ | |
10004 | 1383 static void apply_intensity_stereo(ChannelElement *cpe, int ms_present) |
1384 { | |
1385 const IndividualChannelStream *ics = &cpe->ch[1].ics; | |
1386 SingleChannelElement *sce1 = &cpe->ch[1]; | |
7581 | 1387 float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs; |
10004 | 1388 const uint16_t *offsets = ics->swb_offset; |
7581 | 1389 int g, group, i, k, idx = 0; |
1390 int c; | |
1391 float scale; | |
1392 for (g = 0; g < ics->num_window_groups; g++) { | |
1393 for (i = 0; i < ics->max_sfb;) { | |
1394 if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) { | |
1395 const int bt_run_end = sce1->band_type_run_end[idx]; | |
1396 for (; i < bt_run_end; i++, idx++) { | |
1397 c = -1 + 2 * (sce1->band_type[idx] - 14); | |
1398 if (ms_present) | |
1399 c *= 1 - 2 * cpe->ms_mask[idx]; | |
1400 scale = c * sce1->sf[idx]; | |
1401 for (group = 0; group < ics->group_len[g]; group++) | |
10004 | 1402 for (k = offsets[i]; k < offsets[i + 1]; k++) |
1403 coef1[group * 128 + k] = scale * coef0[group * 128 + k]; | |
7581 | 1404 } |
1405 } else { | |
1406 int bt_run_end = sce1->band_type_run_end[idx]; | |
1407 idx += bt_run_end - i; | |
1408 i = bt_run_end; | |
1409 } | |
1410 } | |
10004 | 1411 coef0 += ics->group_len[g] * 128; |
1412 coef1 += ics->group_len[g] * 128; | |
7581 | 1413 } |
1414 } | |
1415 | |
1416 /** | |
7539 | 1417 * Decode a channel_pair_element; reference: table 4.4. |
1418 * | |
1419 * @return Returns error status. 0 - OK, !0 - error | |
1420 */ | |
10004 | 1421 static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe) |
1422 { | |
7539 | 1423 int i, ret, common_window, ms_present = 0; |
1424 | |
1425 common_window = get_bits1(gb); | |
1426 if (common_window) { | |
1427 if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1)) | |
1428 return -1; | |
1429 i = cpe->ch[1].ics.use_kb_window[0]; | |
1430 cpe->ch[1].ics = cpe->ch[0].ics; | |
1431 cpe->ch[1].ics.use_kb_window[1] = i; | |
1432 ms_present = get_bits(gb, 2); | |
10004 | 1433 if (ms_present == 3) { |
11833 | 1434 av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n"); |
7539 | 1435 return -1; |
10004 | 1436 } else if (ms_present) |
7539 | 1437 decode_mid_side_stereo(cpe, gb, ms_present); |
1438 } | |
1439 if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0))) | |
1440 return ret; | |
1441 if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0))) | |
1442 return ret; | |
1443 | |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1444 if (common_window) { |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1445 if (ms_present) |
10220 | 1446 apply_mid_side_stereo(ac, cpe); |
8413
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1447 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
|
1448 apply_prediction(ac, &cpe->ch[0]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1449 apply_prediction(ac, &cpe->ch[1]); |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1450 } |
6f40f7d77263
AAC: Fix AAC prediction when used in conjunction with the CPE
superdump
parents:
8412
diff
changeset
|
1451 } |
7539 | 1452 |
7580 | 1453 apply_intensity_stereo(cpe, ms_present); |
7539 | 1454 return 0; |
1455 } | |
1456 | |
12153 | 1457 static const float cce_scale[] = { |
1458 1.09050773266525765921, //2^(1/8) | |
1459 1.18920711500272106672, //2^(1/4) | |
1460 M_SQRT2, | |
1461 2, | |
1462 }; | |
1463 | |
7581 | 1464 /** |
1465 * Decode coupling_channel_element; reference: table 4.8. | |
1466 * | |
1467 * @return Returns error status. 0 - OK, !0 - error | |
1468 */ | |
10004 | 1469 static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che) |
1470 { | |
7581 | 1471 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
|
1472 int c, g, sfb, ret; |
7581 | 1473 int sign; |
1474 float scale; | |
10004 | 1475 SingleChannelElement *sce = &che->ch[0]; |
1476 ChannelCoupling *coup = &che->coup; | |
7581 | 1477 |
10004 | 1478 coup->coupling_point = 2 * get_bits1(gb); |
7578 | 1479 coup->num_coupled = get_bits(gb, 3); |
1480 for (c = 0; c <= coup->num_coupled; c++) { | |
1481 num_gain++; | |
1482 coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE; | |
1483 coup->id_select[c] = get_bits(gb, 4); | |
1484 if (coup->type[c] == TYPE_CPE) { | |
1485 coup->ch_select[c] = get_bits(gb, 2); | |
1486 if (coup->ch_select[c] == 3) | |
1487 num_gain++; | |
1488 } else | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1489 coup->ch_select[c] = 2; |
7578 | 1490 } |
10004 | 1491 coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1); |
7578 | 1492 |
10004 | 1493 sign = get_bits(gb, 1); |
12153 | 1494 scale = cce_scale[get_bits(gb, 2)]; |
7578 | 1495 |
1496 if ((ret = decode_ics(ac, sce, gb, 0, 0))) | |
1497 return ret; | |
1498 | |
1499 for (c = 0; c < num_gain; c++) { | |
10004 | 1500 int idx = 0; |
1501 int cge = 1; | |
7578 | 1502 int gain = 0; |
1503 float gain_cache = 1.; | |
1504 if (c) { | |
1505 cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb); | |
1506 gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0; | |
12154
8a50de6cf3f1
aacdec: Eliminate the use of doubles in decode_cce().
alexc
parents:
12153
diff
changeset
|
1507 gain_cache = powf(scale, -gain); |
7578 | 1508 } |
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
|
1509 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
|
1510 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
|
1511 } else { |
8823 | 1512 for (g = 0; g < sce->ics.num_window_groups; g++) { |
1513 for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) { | |
1514 if (sce->band_type[idx] != ZERO_BT) { | |
1515 if (!cge) { | |
1516 int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; | |
10004 | 1517 if (t) { |
8823 | 1518 int s = 1; |
1519 t = gain += t; | |
1520 if (sign) { | |
1521 s -= 2 * (t & 0x1); | |
1522 t >>= 1; | |
1523 } | |
12154
8a50de6cf3f1
aacdec: Eliminate the use of doubles in decode_cce().
alexc
parents:
12153
diff
changeset
|
1524 gain_cache = powf(scale, -t) * s; |
7578 | 1525 } |
1526 } | |
8823 | 1527 coup->gain[c][idx] = gain_cache; |
7578 | 1528 } |
1529 } | |
7890 | 1530 } |
1531 } | |
7578 | 1532 } |
1533 return 0; | |
1534 } | |
1535 | |
7539 | 1536 /** |
7578 | 1537 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53. |
1538 * | |
1539 * @return Returns number of bytes consumed. | |
1540 */ | |
10004 | 1541 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, |
1542 GetBitContext *gb) | |
1543 { | |
7578 | 1544 int i; |
1545 int num_excl_chan = 0; | |
1546 | |
1547 do { | |
1548 for (i = 0; i < 7; i++) | |
1549 che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb); | |
1550 } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb)); | |
1551 | |
1552 return num_excl_chan / 7; | |
1553 } | |
1554 | |
1555 /** | |
7539 | 1556 * Decode dynamic range information; reference: table 4.52. |
1557 * | |
1558 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1559 * | |
1560 * @return Returns number of bytes consumed. | |
1561 */ | |
10004 | 1562 static int decode_dynamic_range(DynamicRangeControl *che_drc, |
1563 GetBitContext *gb, int cnt) | |
1564 { | |
1565 int n = 1; | |
7539 | 1566 int drc_num_bands = 1; |
1567 int i; | |
1568 | |
1569 /* pce_tag_present? */ | |
10004 | 1570 if (get_bits1(gb)) { |
7539 | 1571 che_drc->pce_instance_tag = get_bits(gb, 4); |
1572 skip_bits(gb, 4); // tag_reserved_bits | |
1573 n++; | |
1574 } | |
1575 | |
1576 /* excluded_chns_present? */ | |
10004 | 1577 if (get_bits1(gb)) { |
7539 | 1578 n += decode_drc_channel_exclusions(che_drc, gb); |
1579 } | |
1580 | |
1581 /* drc_bands_present? */ | |
1582 if (get_bits1(gb)) { | |
1583 che_drc->band_incr = get_bits(gb, 4); | |
1584 che_drc->interpolation_scheme = get_bits(gb, 4); | |
1585 n++; | |
1586 drc_num_bands += che_drc->band_incr; | |
1587 for (i = 0; i < drc_num_bands; i++) { | |
1588 che_drc->band_top[i] = get_bits(gb, 8); | |
1589 n++; | |
1590 } | |
1591 } | |
1592 | |
1593 /* prog_ref_level_present? */ | |
1594 if (get_bits1(gb)) { | |
1595 che_drc->prog_ref_level = get_bits(gb, 7); | |
1596 skip_bits1(gb); // prog_ref_level_reserved_bits | |
1597 n++; | |
1598 } | |
1599 | |
1600 for (i = 0; i < drc_num_bands; i++) { | |
1601 che_drc->dyn_rng_sgn[i] = get_bits1(gb); | |
1602 che_drc->dyn_rng_ctl[i] = get_bits(gb, 7); | |
1603 n++; | |
1604 } | |
1605 | |
1606 return n; | |
1607 } | |
1608 | |
1609 /** | |
1610 * Decode extension data (incomplete); reference: table 4.51. | |
1611 * | |
1612 * @param cnt length of TYPE_FIL syntactic element in bytes | |
1613 * | |
1614 * @return Returns number of bytes consumed | |
1615 */ | |
11401 | 1616 static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt, |
1617 ChannelElement *che, enum RawDataBlockType elem_type) | |
10004 | 1618 { |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1619 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
|
1620 int res = cnt; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1621 switch (get_bits(gb, 4)) { // extension type |
10004 | 1622 case EXT_SBR_DATA_CRC: |
1623 crc_flag++; | |
1624 case EXT_SBR_DATA: | |
11401 | 1625 if (!che) { |
11833 | 1626 av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n"); |
11401 | 1627 return res; |
1628 } else if (!ac->m4ac.sbr) { | |
11833 | 1629 av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n"); |
11401 | 1630 skip_bits_long(gb, 8 * cnt - 4); |
1631 return res; | |
1632 } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) { | |
11833 | 1633 av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n"); |
11401 | 1634 skip_bits_long(gb, 8 * cnt - 4); |
1635 return res; | |
11886 | 1636 } else if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) { |
1637 ac->m4ac.sbr = 1; | |
1638 ac->m4ac.ps = 1; | |
1639 output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured); | |
11401 | 1640 } else { |
1641 ac->m4ac.sbr = 1; | |
1642 } | |
1643 res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type); | |
10004 | 1644 break; |
1645 case EXT_DYNAMIC_RANGE: | |
1646 res = decode_dynamic_range(&ac->che_drc, gb, cnt); | |
1647 break; | |
1648 case EXT_FILL: | |
1649 case EXT_FILL_DATA: | |
1650 case EXT_DATA_ELEMENT: | |
1651 default: | |
1652 skip_bits_long(gb, 8 * cnt - 4); | |
1653 break; | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1654 }; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1655 return res; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1656 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1657 |
7632
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1658 /** |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1659 * 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
|
1660 * |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1661 * @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
|
1662 * @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
|
1663 */ |
10004 | 1664 static void apply_tns(float coef[1024], TemporalNoiseShaping *tns, |
1665 IndividualChannelStream *ics, int decode) | |
1666 { | |
1667 const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb); | |
7636 | 1668 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
|
1669 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
|
1670 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
|
1671 |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1672 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
|
1673 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
|
1674 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
|
1675 top = bottom; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1676 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
|
1677 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
|
1678 if (order == 0) |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1679 continue; |
ac583bd8f8b3
Last hunk of the AAC decoder code to be OKed and build system and documentation
superdump
parents:
7609
diff
changeset
|
1680 |
7788
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1681 // tns_decode_coef |
ffd4b1364b62
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
vitor
parents:
7733
diff
changeset
|
1682 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
|
1683 |
7609 | 1684 start = ics->swb_offset[FFMIN(bottom, mmm)]; |
1685 end = ics->swb_offset[FFMIN( top, mmm)]; | |
1686 if ((size = end - start) <= 0) | |
1687 continue; | |
1688 if (tns->direction[w][filt]) { | |
10004 | 1689 inc = -1; |
1690 start = end - 1; | |
7609 | 1691 } else { |
1692 inc = 1; | |
1693 } | |
1694 start += w * 128; | |
1695 | |
1696 // ar filter | |
1697 for (m = 0; m < size; m++, start += inc) | |
1698 for (i = 1; i <= FFMIN(m, order); i++) | |
10004 | 1699 coef[start] -= coef[start - i * inc] * lpc[i - 1]; |
7609 | 1700 } |
1701 } | |
1702 } | |
1703 | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1704 /** |
7539 | 1705 * Conduct IMDCT and windowing. |
1706 */ | |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1707 static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce, float bias) |
10004 | 1708 { |
1709 IndividualChannelStream *ics = &sce->ics; | |
1710 float *in = sce->coeffs; | |
1711 float *out = sce->ret; | |
1712 float *saved = sce->saved; | |
1713 const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; | |
1714 const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; | |
1715 const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; | |
1716 float *buf = ac->buf_mdct; | |
1717 float *temp = ac->temp; | |
7539 | 1718 int i; |
1719 | |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1720 // imdct |
7578 | 1721 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
|
1722 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
|
1723 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
|
1724 } else |
7663
66fb1f3937fa
Use ff_imdct_half() and vector_fmul_window() for IMDCT and windowing. Reduce
superdump
parents:
7662
diff
changeset
|
1725 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
|
1726 |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1727 /* window overlapping |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1728 * 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
|
1729 * 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
|
1730 * 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
|
1731 * 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
|
1732 */ |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1733 if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) && |
10004 | 1734 (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
|
1735 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
|
1736 } else { |
7662 | 1737 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
|
1738 out[i] = saved[i] + bias; |
7578 | 1739 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1740 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
|
1741 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
|
1742 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
|
1743 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
|
1744 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
|
1745 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
|
1746 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
|
1747 } else { |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1748 ac->dsp.vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, bias, 64); |
7662 | 1749 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
|
1750 out[i] = buf[i-512] + bias; |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1751 } |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1752 } |
7578 | 1753 |
7661
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1754 // buffer update |
258eb30e6f7d
Separate code in imdct_and_windowing() into distinct IMDCT, windowing and
superdump
parents:
7638
diff
changeset
|
1755 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
|
1756 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
|
1757 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
|
1758 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
|
1759 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
|
1760 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
|
1761 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
|
1762 } 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
|
1763 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
|
1764 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
|
1765 } 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
|
1766 memcpy( saved, buf + 512, 512 * sizeof(float)); |
7578 | 1767 } |
1768 } | |
1769 | |
7539 | 1770 /** |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1771 * 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
|
1772 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1773 * @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
|
1774 */ |
10004 | 1775 static void apply_dependent_coupling(AACContext *ac, |
1776 SingleChannelElement *target, | |
1777 ChannelElement *cce, int index) | |
1778 { | |
1779 IndividualChannelStream *ics = &cce->ch[0].ics; | |
1780 const uint16_t *offsets = ics->swb_offset; | |
1781 float *dest = target->coeffs; | |
1782 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
|
1783 int g, i, group, k, idx = 0; |
10004 | 1784 if (ac->m4ac.object_type == AOT_AAC_LTP) { |
11833 | 1785 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
|
1786 "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
|
1787 return; |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1788 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1789 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
|
1790 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
|
1791 if (cce->ch[0].band_type[idx] != ZERO_BT) { |
9143 | 1792 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
|
1793 for (group = 0; group < ics->group_len[g]; group++) { |
10004 | 1794 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
|
1795 // XXX dsputil-ize |
10004 | 1796 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
|
1797 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1798 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1799 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1800 } |
10004 | 1801 dest += ics->group_len[g] * 128; |
1802 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
|
1803 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1804 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1805 |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1806 /** |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1807 * 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
|
1808 * |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1809 * @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
|
1810 */ |
10004 | 1811 static void apply_independent_coupling(AACContext *ac, |
1812 SingleChannelElement *target, | |
1813 ChannelElement *cce, int index) | |
1814 { | |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1815 int i; |
9051
0cffed11ee33
Use const to better allow the compiler to optimize AAC independent coupling.
alexc
parents:
8823
diff
changeset
|
1816 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
|
1817 const float bias = ac->add_bias; |
10004 | 1818 const float *src = cce->ch[0].ret; |
1819 float *dest = target->ret; | |
11401 | 1820 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
|
1821 |
11401 | 1822 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
|
1823 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
|
1824 } |
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
1825 |
7581 | 1826 /** |
1827 * channel coupling transformation interface | |
1828 * | |
1829 * @param apply_coupling_method pointer to (in)dependent coupling function | |
1830 */ | |
10004 | 1831 static void apply_channel_coupling(AACContext *ac, ChannelElement *cc, |
1832 enum RawDataBlockType type, int elem_id, | |
1833 enum CouplingPoint coupling_point, | |
1834 void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)) | |
7581 | 1835 { |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1836 int i, c; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1837 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1838 for (i = 0; i < MAX_ELEM_ID; i++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1839 ChannelElement *cce = ac->che[TYPE_CCE][i]; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1840 int index = 0; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1841 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1842 if (cce && cce->coup.coupling_point == coupling_point) { |
10004 | 1843 ChannelCoupling *coup = &cce->coup; |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1844 |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1845 for (c = 0; c <= coup->num_coupled; c++) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1846 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
|
1847 if (coup->ch_select[c] != 1) { |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1848 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
|
1849 if (coup->ch_select[c] != 0) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1850 index++; |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1851 } |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1852 if (coup->ch_select[c] != 2) |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1853 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
|
1854 } else |
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1855 index += 1 + (coup->ch_select[c] == 3); |
7581 | 1856 } |
1857 } | |
1858 } | |
1859 } | |
1860 | |
1861 /** | |
1862 * Convert spectral data to float samples, applying all supported tools as appropriate. | |
1863 */ | |
10004 | 1864 static void spectral_to_sample(AACContext *ac) |
1865 { | |
10688 | 1866 int i, type; |
11481
96dde15b2e0d
aac: Don't bias output during the IMDCT if SBR will be used.
alexc
parents:
11401
diff
changeset
|
1867 float imdct_bias = (ac->m4ac.sbr <= 0) ? ac->add_bias : 0.0f; |
10688 | 1868 for (type = 3; type >= 0; type--) { |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1869 for (i = 0; i < MAX_ELEM_ID; i++) { |
7581 | 1870 ChannelElement *che = ac->che[type][i]; |
10004 | 1871 if (che) { |
1872 if (type <= TYPE_CPE) | |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1873 apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling); |
10004 | 1874 if (che->ch[0].tns.present) |
7581 | 1875 apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1); |
10004 | 1876 if (che->ch[1].tns.present) |
7581 | 1877 apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1); |
10004 | 1878 if (type <= TYPE_CPE) |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1879 apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling); |
11401 | 1880 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
|
1881 imdct_and_windowing(ac, &che->ch[0], imdct_bias); |
11668 | 1882 if (type == TYPE_CPE) { |
1883 imdct_and_windowing(ac, &che->ch[1], imdct_bias); | |
1884 } | |
11667
6818ea5a25a2
Rewrite ff_sbr_apply in a manner more friendly to PS.
alexc
parents:
11644
diff
changeset
|
1885 if (ac->m4ac.sbr > 0) { |
6818ea5a25a2
Rewrite ff_sbr_apply in a manner more friendly to PS.
alexc
parents:
11644
diff
changeset
|
1886 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
|
1887 } |
11401 | 1888 } |
10004 | 1889 if (type <= TYPE_CCE) |
8004
8fd8f23be794
Corrections to channel coupling code to attain conformance for appropriate
superdump
parents:
7891
diff
changeset
|
1890 apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling); |
7578 | 1891 } |
1892 } | |
1893 } | |
1894 } | |
1895 | |
10004 | 1896 static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb) |
1897 { | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1898 int size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1899 AACADTSHeaderInfo hdr_info; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1900 |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1901 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
|
1902 if (size > 0) { |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1903 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
|
1904 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
|
1905 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
|
1906 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
|
1907 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
|
1908 return -7; |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1909 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
|
1910 return -7; |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
1911 } 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
|
1912 ac->output_configured = OC_NONE; |
9948
98fd723f72e7
Ignore subsequent channel configurations after the first in an AAC file. The
alexc
parents:
9891
diff
changeset
|
1913 } |
11886 | 1914 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
|
1915 ac->m4ac.sbr = -1; |
11886 | 1916 ac->m4ac.ps = -1; |
1917 } | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1918 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
|
1919 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
|
1920 ac->m4ac.object_type = hdr_info.object_type; |
11833 | 1921 if (!ac->avctx->sample_rate) |
1922 ac->avctx->sample_rate = hdr_info.sample_rate; | |
9151 | 1923 if (hdr_info.num_aac_frames == 1) { |
1924 if (!hdr_info.crc_absent) | |
1925 skip_bits(gb, 16); | |
1926 } else { | |
11833 | 1927 av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame is", 0); |
9151 | 1928 return -1; |
1929 } | |
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
|
1930 } |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1931 return size; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1932 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1933 |
11833 | 1934 static int aac_decode_frame(AVCodecContext *avctx, void *data, |
10004 | 1935 int *data_size, AVPacket *avpkt) |
1936 { | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9251
diff
changeset
|
1937 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9251
diff
changeset
|
1938 int buf_size = avpkt->size; |
11833 | 1939 AACContext *ac = avctx->priv_data; |
11401 | 1940 ChannelElement *che = NULL, *che_prev = NULL; |
7578 | 1941 GetBitContext gb; |
11401 | 1942 enum RawDataBlockType elem_type, elem_type_prev = TYPE_END; |
7578 | 1943 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
|
1944 int buf_consumed; |
11902 | 1945 int samples = 0, multiplier; |
11746
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
1946 int buf_offset; |
7578 | 1947 |
10004 | 1948 init_get_bits(&gb, buf, buf_size * 8); |
7578 | 1949 |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1950 if (show_bits(&gb, 12) == 0xfff) { |
9510 | 1951 if (parse_adts_frame_header(ac, &gb) < 0) { |
11833 | 1952 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
|
1953 return -1; |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1954 } |
8812 | 1955 if (ac->m4ac.sampling_index > 12) { |
11833 | 1956 av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); |
8789 | 1957 return -1; |
1958 } | |
8549
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1959 } |
2cbfa4cd4670
Support ADTS AAC files in the ffaac decoder (limited to streams containing one
superdump
parents:
8502
diff
changeset
|
1960 |
11819
9bdc0fe882fa
aacdec: Work around illegal files with all elem_id tags set to the same value.
alexc
parents:
11787
diff
changeset
|
1961 memset(ac->tags_seen_this_frame, 0, sizeof(ac->tags_seen_this_frame)); |
7578 | 1962 // parse |
1963 while ((elem_type = get_bits(&gb, 3)) != TYPE_END) { | |
1964 elem_id = get_bits(&gb, 4); | |
1965 | |
11903 | 1966 if (elem_type < TYPE_DSE) { |
11904 | 1967 if (!(che=get_che(ac, elem_type, elem_id))) { |
1968 av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", | |
1969 elem_type, elem_id); | |
1970 return -1; | |
1971 } | |
11902 | 1972 samples = 1024; |
11903 | 1973 } |
11902 | 1974 |
7578 | 1975 switch (elem_type) { |
1976 | |
1977 case TYPE_SCE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1978 err = decode_ics(ac, &che->ch[0], &gb, 0, 0); |
7578 | 1979 break; |
1980 | |
1981 case TYPE_CPE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1982 err = decode_cpe(ac, &gb, che); |
7578 | 1983 break; |
1984 | |
1985 case TYPE_CCE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1986 err = decode_cce(ac, &gb, che); |
7578 | 1987 break; |
1988 | |
1989 case TYPE_LFE: | |
9149
955835e2bc99
Fix the channel allocation bug/assumption (issue 800).
alexc
parents:
9143
diff
changeset
|
1990 err = decode_ics(ac, &che->ch[0], &gb, 0, 0); |
7578 | 1991 break; |
1992 | |
1993 case TYPE_DSE: | |
11205 | 1994 err = skip_data_stream_element(ac, &gb); |
7578 | 1995 break; |
1996 | |
10004 | 1997 case TYPE_PCE: { |
7578 | 1998 enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; |
1999 memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); | |
10004 | 2000 if ((err = decode_pce(ac, new_che_pos, &gb))) |
7578 | 2001 break; |
10551
a0dd118e82ae
10l: Fix inverted if-condition from r20448. Fixes issue 1562.
alexc
parents:
10519
diff
changeset
|
2002 if (ac->output_configured > OC_TRIAL_PCE) |
11833 | 2003 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
|
2004 "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
|
2005 else |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2006 err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE); |
7578 | 2007 break; |
2008 } | |
2009 | |
2010 case TYPE_FIL: | |
2011 if (elem_id == 15) | |
2012 elem_id += get_bits(&gb, 8) - 1; | |
11205 | 2013 if (get_bits_left(&gb) < 8 * elem_id) { |
11833 | 2014 av_log(avctx, AV_LOG_ERROR, overread_err); |
11205 | 2015 return -1; |
2016 } | |
7578 | 2017 while (elem_id > 0) |
11401 | 2018 elem_id -= decode_extension_payload(ac, &gb, elem_id, che_prev, elem_type_prev); |
7578 | 2019 err = 0; /* FIXME */ |
2020 break; | |
2021 | |
2022 default: | |
2023 err = -1; /* should not happen, but keeps compiler happy */ | |
2024 break; | |
2025 } | |
2026 | |
11401 | 2027 che_prev = che; |
2028 elem_type_prev = elem_type; | |
2029 | |
10004 | 2030 if (err) |
7578 | 2031 return err; |
11205 | 2032 |
2033 if (get_bits_left(&gb) < 3) { | |
11833 | 2034 av_log(avctx, AV_LOG_ERROR, overread_err); |
11205 | 2035 return -1; |
2036 } | |
7578 | 2037 } |
2038 | |
2039 spectral_to_sample(ac); | |
2040 | |
11401 | 2041 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
|
2042 samples <<= multiplier; |
d23864bc3887
AAC: Set codec parameters in the first frame rather than in .init()
alexc
parents:
11388
diff
changeset
|
2043 if (ac->output_configured < OC_LOCKED) { |
11833 | 2044 avctx->sample_rate = ac->m4ac.sample_rate << multiplier; |
2045 avctx->frame_size = samples; | |
11393
d23864bc3887
AAC: Set codec parameters in the first frame rather than in .init()
alexc
parents:
11388
diff
changeset
|
2046 } |
d23864bc3887
AAC: Set codec parameters in the first frame rather than in .init()
alexc
parents:
11388
diff
changeset
|
2047 |
11833 | 2048 data_size_tmp = samples * avctx->channels * sizeof(int16_t); |
10004 | 2049 if (*data_size < data_size_tmp) { |
11833 | 2050 av_log(avctx, AV_LOG_ERROR, |
7539 | 2051 "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n", |
2052 *data_size, data_size_tmp); | |
2053 return -1; | |
2054 } | |
2055 *data_size = data_size_tmp; | |
2056 | |
11902 | 2057 if (samples) |
11905 | 2058 ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels); |
7539 | 2059 |
10491
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2060 if (ac->output_configured) |
74e51b86b934
Don't lock the channel output configuration based on the first value seen for
alexc
parents:
10378
diff
changeset
|
2061 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
|
2062 |
11362
1682a19a0881
AAC: Return the number of bytes consumed in decoding a frame.
alexc
parents:
11358
diff
changeset
|
2063 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
|
2064 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
|
2065 if (buf[buf_offset]) |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2066 break; |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2067 |
818851623979
Make aac_decode_frame() consume zero padding at the end of a packet.
alexc
parents:
11668
diff
changeset
|
2068 return buf_size > buf_offset ? buf_consumed : buf_size; |
7539 | 2069 } |
2070 | |
11833 | 2071 static av_cold int aac_decode_close(AVCodecContext *avctx) |
10004 | 2072 { |
11833 | 2073 AACContext *ac = avctx->priv_data; |
7540 | 2074 int i, type; |
7501 | 2075 |
7523
a3f7ffdb676d
Sync already committed code with that in SoC and commit more OKed hunks of code
superdump
parents:
7501
diff
changeset
|
2076 for (i = 0; i < MAX_ELEM_ID; i++) { |
11401 | 2077 for (type = 0; type < 4; type++) { |
2078 if (ac->che[type][i]) | |
2079 ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr); | |
7540 | 2080 av_freep(&ac->che[type][i]); |
11401 | 2081 } |
7501 | 2082 } |
2083 | |
2084 ff_mdct_end(&ac->mdct); | |
2085 ff_mdct_end(&ac->mdct_small); | |
10004 | 2086 return 0; |
7501 | 2087 } |
2088 | |
2089 AVCodec aac_decoder = { | |
2090 "aac", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11489
diff
changeset
|
2091 AVMEDIA_TYPE_AUDIO, |
7501 | 2092 CODEC_ID_AAC, |
2093 sizeof(AACContext), | |
2094 aac_decode_init, | |
2095 NULL, | |
2096 aac_decode_close, | |
2097 aac_decode_frame, | |
2098 .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
|
2099 .sample_fmts = (const enum SampleFormat[]) { |
10004 | 2100 SAMPLE_FMT_S16,SAMPLE_FMT_NONE |
2101 }, | |
10306
c97a6cabee62
AAC: Add channel layout support for channel configuration as defined in the
superdump
parents:
10252
diff
changeset
|
2102 .channel_layouts = aac_channel_layout, |
7501 | 2103 }; |