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