Mercurial > libavcodec.hg
annotate eac3dec.c @ 7983:47f50599b368 libavcodec
x264 has removed the b-rdo and bime options, and instead integrated
them into the subme number to attempt to reduce the number of
unnecessary options. subme now scales up to 9.
Patch by Jason Garett-Glaser %darkshikari A gmail P com%
author | gpoirier |
---|---|
date | Thu, 02 Oct 2008 19:05:35 +0000 |
parents | 1c0e498ac7bd |
children | 3085502c4f33 |
rev | line source |
---|---|
7666 | 1 /* |
2 * E-AC-3 decoder | |
3 * Copyright (c) 2007 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com> | |
4 * Copyright (c) 2008 Justin Ruggles | |
5 * | |
6 * This file is part of FFmpeg. | |
7 * | |
8 * FFmpeg is free software; you can redistribute it and/or | |
7679 | 9 * modify it under the terms of the GNU Lesser General Public |
7666 | 10 * License as published by the Free Software Foundation; either |
7679 | 11 * version 2.1 of the License, or (at your option) any later version. |
7666 | 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 | |
7679 | 16 * Lesser General Public License for more details. |
7666 | 17 * |
7679 | 18 * You should have received a copy of the GNU Lesser General Public |
7666 | 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 #include "avcodec.h" | |
24 #include "ac3.h" | |
25 #include "ac3_parser.h" | |
26 #include "ac3dec.h" | |
27 #include "ac3dec_data.h" | |
28 | |
29 /** gain adaptive quantization mode */ | |
30 typedef enum { | |
31 EAC3_GAQ_NO =0, | |
32 EAC3_GAQ_12, | |
33 EAC3_GAQ_14, | |
34 EAC3_GAQ_124 | |
35 } EAC3GaqMode; | |
36 | |
37 #define EAC3_SR_CODE_REDUCED 3 | |
38 | |
39 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */ | |
40 #define COEFF_0 10273905LL | |
41 | |
42 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */ | |
43 #define COEFF_1 11863283LL | |
44 | |
45 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */ | |
46 #define COEFF_2 3070444LL | |
47 | |
48 /** | |
49 * Calculate 6-point IDCT of the pre-mantissas. | |
50 * All calculations are 24-bit fixed-point. | |
51 */ | |
52 static void idct6(int pre_mant[6]) | |
53 { | |
54 int tmp; | |
55 int even0, even1, even2, odd0, odd1, odd2; | |
56 | |
57 odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5]; | |
58 | |
59 even2 = ( pre_mant[2] * COEFF_0) >> 23; | |
60 tmp = ( pre_mant[4] * COEFF_1) >> 23; | |
61 odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23; | |
62 | |
63 even0 = pre_mant[0] + (tmp >> 1); | |
64 even1 = pre_mant[0] - tmp; | |
65 | |
66 tmp = even0; | |
67 even0 = tmp + even2; | |
68 even2 = tmp - even2; | |
69 | |
70 tmp = odd0; | |
71 odd0 = tmp + pre_mant[1] + pre_mant[3]; | |
72 odd2 = tmp + pre_mant[5] - pre_mant[3]; | |
73 | |
74 pre_mant[0] = even0 + odd0; | |
75 pre_mant[1] = even1 + odd1; | |
76 pre_mant[2] = even2 + odd2; | |
77 pre_mant[3] = even2 - odd2; | |
78 pre_mant[4] = even1 - odd1; | |
79 pre_mant[5] = even0 - odd0; | |
80 } | |
7745 | 81 |
82 void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch) | |
83 { | |
84 int bin, blk, gs; | |
85 int end_bap, gaq_mode; | |
86 GetBitContext *gbc = &s->gbc; | |
87 int gaq_gain[AC3_MAX_COEFS]; | |
88 | |
89 gaq_mode = get_bits(gbc, 2); | |
90 end_bap = (gaq_mode < 2) ? 12 : 17; | |
91 | |
92 /* if GAQ gain is used, decode gain codes for bins with hebap between | |
93 8 and end_bap */ | |
94 gs = 0; | |
95 if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) { | |
96 /* read 1-bit GAQ gain codes */ | |
97 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { | |
98 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap) | |
99 gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1); | |
100 } | |
101 } else if (gaq_mode == EAC3_GAQ_124) { | |
102 /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */ | |
103 int gc = 2; | |
104 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { | |
105 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) { | |
106 if (gc++ == 2) { | |
107 int group_code = get_bits(gbc, 5); | |
108 if (group_code > 26) { | |
109 av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n"); | |
110 group_code = 26; | |
111 } | |
112 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0]; | |
113 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1]; | |
114 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2]; | |
115 gc = 0; | |
116 } | |
117 } | |
118 } | |
119 } | |
120 | |
121 gs=0; | |
122 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { | |
123 int hebap = s->bap[ch][bin]; | |
124 int bits = ff_eac3_bits_vs_hebap[hebap]; | |
125 if (!hebap) { | |
126 /* zero-mantissa dithering */ | |
127 for (blk = 0; blk < 6; blk++) { | |
128 s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000; | |
129 } | |
130 } else if (hebap < 8) { | |
131 /* Vector Quantization */ | |
132 int v = get_bits(gbc, bits); | |
133 for (blk = 0; blk < 6; blk++) { | |
7754 | 134 s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8; |
7745 | 135 } |
136 } else { | |
137 /* Gain Adaptive Quantization */ | |
138 int gbits, log_gain; | |
139 if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) { | |
140 log_gain = gaq_gain[gs++]; | |
141 } else { | |
142 log_gain = 0; | |
143 } | |
144 gbits = bits - log_gain; | |
145 | |
146 for (blk = 0; blk < 6; blk++) { | |
147 int mant = get_sbits(gbc, gbits); | |
148 if (mant == -(1 << (gbits-1))) { | |
149 /* large mantissa */ | |
150 int b; | |
151 mant = get_sbits(gbc, bits-2+log_gain) << (26-log_gain-bits); | |
152 /* remap mantissa value to correct for asymmetric quantization */ | |
153 if (mant >= 0) | |
154 b = 32768 >> (log_gain+8); | |
155 else | |
156 b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1]; | |
157 mant += (ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (mant>>8) + b) >> 7; | |
158 } else { | |
159 /* small mantissa, no GAQ, or Gk=1 */ | |
160 mant <<= 24 - bits; | |
161 if (!log_gain) { | |
162 /* remap mantissa value for no GAQ or Gk=1 */ | |
163 mant += (ff_eac3_gaq_remap_1[hebap-8] * (mant>>8)) >> 7; | |
164 } | |
165 } | |
166 s->pre_mantissa[ch][bin][blk] = mant; | |
167 } | |
168 } | |
169 idct6(s->pre_mantissa[ch][bin]); | |
170 } | |
171 } | |
172 | |
173 int ff_eac3_parse_header(AC3DecodeContext *s) | |
174 { | |
175 int i, blk, ch; | |
176 int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data; | |
177 int parse_transient_proc_info; | |
178 int num_cpl_blocks; | |
179 GetBitContext *gbc = &s->gbc; | |
180 | |
181 /* An E-AC-3 stream can have multiple independent streams which the | |
182 application can select from. each independent stream can also contain | |
183 dependent streams which are used to add or replace channels. */ | |
184 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) { | |
185 av_log_missing_feature(s->avctx, "Dependent substream decoding", 1); | |
186 return AC3_PARSE_ERROR_FRAME_TYPE; | |
187 } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) { | |
188 av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n"); | |
189 return AC3_PARSE_ERROR_FRAME_TYPE; | |
190 } | |
191 | |
192 /* The substream id indicates which substream this frame belongs to. each | |
193 independent stream has its own substream id, and the dependent streams | |
194 associated to an independent stream have matching substream id's. */ | |
195 if (s->substreamid) { | |
196 /* only decode substream with id=0. skip any additional substreams. */ | |
197 av_log_missing_feature(s->avctx, "Additional substreams", 1); | |
198 return AC3_PARSE_ERROR_FRAME_TYPE; | |
199 } | |
200 | |
201 if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) { | |
202 /* The E-AC-3 specification does not tell how to handle reduced sample | |
203 rates in bit allocation. The best assumption would be that it is | |
204 handled like AC-3 DolbyNet, but we cannot be sure until we have a | |
205 sample which utilizes this feature. */ | |
206 av_log_missing_feature(s->avctx, "Reduced sampling rates", 1); | |
207 return -1; | |
208 } | |
209 skip_bits(gbc, 5); // skip bitstream id | |
210 | |
211 /* volume control params */ | |
212 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
213 skip_bits(gbc, 5); // skip dialog normalization | |
214 if (get_bits1(gbc)) { | |
215 skip_bits(gbc, 8); // skip compression gain word | |
216 } | |
217 } | |
218 | |
219 /* dependent stream channel map */ | |
220 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) { | |
221 if (get_bits1(gbc)) { | |
222 skip_bits(gbc, 16); // skip custom channel map | |
223 } | |
224 } | |
225 | |
226 /* mixing metadata */ | |
227 if (get_bits1(gbc)) { | |
228 /* center and surround mix levels */ | |
229 if (s->channel_mode > AC3_CHMODE_STEREO) { | |
230 skip_bits(gbc, 2); // skip preferred stereo downmix mode | |
231 if (s->channel_mode & 1) { | |
232 /* if three front channels exist */ | |
233 skip_bits(gbc, 3); //skip Lt/Rt center mix level | |
234 s->center_mix_level = get_bits(gbc, 3); | |
235 } | |
236 if (s->channel_mode & 4) { | |
237 /* if a surround channel exists */ | |
238 skip_bits(gbc, 3); //skip Lt/Rt surround mix level | |
239 s->surround_mix_level = get_bits(gbc, 3); | |
240 } | |
241 } | |
242 | |
243 /* lfe mix level */ | |
244 if (s->lfe_on && get_bits1(gbc)) { | |
245 // TODO: use LFE mix level | |
246 skip_bits(gbc, 5); // skip LFE mix level code | |
247 } | |
248 | |
249 /* info for mixing with other streams and substreams */ | |
250 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) { | |
251 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
252 // TODO: apply program scale factor | |
253 if (get_bits1(gbc)) { | |
254 skip_bits(gbc, 6); // skip program scale factor | |
255 } | |
256 } | |
257 if (get_bits1(gbc)) { | |
258 skip_bits(gbc, 6); // skip external program scale factor | |
259 } | |
260 /* skip mixing parameter data */ | |
261 switch(get_bits(gbc, 2)) { | |
262 case 1: skip_bits(gbc, 5); break; | |
263 case 2: skip_bits(gbc, 12); break; | |
264 case 3: { | |
265 int mix_data_size = (get_bits(gbc, 5) + 2) << 3; | |
266 skip_bits_long(gbc, mix_data_size); | |
267 break; | |
268 } | |
269 } | |
270 /* skip pan information for mono or dual mono source */ | |
271 if (s->channel_mode < AC3_CHMODE_STEREO) { | |
272 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
273 if (get_bits1(gbc)) { | |
274 /* note: this is not in the ATSC A/52B specification | |
275 reference: ETSI TS 102 366 V1.1.1 | |
276 section: E.1.3.1.25 */ | |
277 skip_bits(gbc, 8); // skip pan mean direction index | |
278 skip_bits(gbc, 6); // skip reserved paninfo bits | |
279 } | |
280 } | |
281 } | |
282 /* skip mixing configuration information */ | |
283 if (get_bits1(gbc)) { | |
284 for (blk = 0; blk < s->num_blocks; blk++) { | |
285 if (s->num_blocks == 1 || get_bits1(gbc)) { | |
286 skip_bits(gbc, 5); | |
287 } | |
288 } | |
289 } | |
290 } | |
291 } | |
292 | |
293 /* informational metadata */ | |
294 if (get_bits1(gbc)) { | |
295 skip_bits(gbc, 3); // skip bit stream mode | |
296 skip_bits(gbc, 2); // skip copyright bit and original bitstream bit | |
297 if (s->channel_mode == AC3_CHMODE_STEREO) { | |
298 skip_bits(gbc, 4); // skip Dolby surround and headphone mode | |
299 } | |
300 if (s->channel_mode >= AC3_CHMODE_2F2R) { | |
301 skip_bits(gbc, 2); // skip Dolby surround EX mode | |
302 } | |
303 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
304 if (get_bits1(gbc)) { | |
305 skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type | |
306 } | |
307 } | |
308 if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) { | |
309 skip_bits1(gbc); // skip source sample rate code | |
310 } | |
311 } | |
312 | |
313 /* converter synchronization flag | |
314 If frames are less than six blocks, this bit should be turned on | |
315 once every 6 blocks to indicate the start of a frame set. | |
316 reference: RFC 4598, Section 2.1.3 Frame Sets */ | |
317 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) { | |
318 skip_bits1(gbc); // skip converter synchronization flag | |
319 } | |
320 | |
321 /* original frame size code if this stream was converted from AC-3 */ | |
322 if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT && | |
323 (s->num_blocks == 6 || get_bits1(gbc))) { | |
324 skip_bits(gbc, 6); // skip frame size code | |
325 } | |
326 | |
327 /* additional bitstream info */ | |
328 if (get_bits1(gbc)) { | |
329 int addbsil = get_bits(gbc, 6); | |
330 for (i = 0; i < addbsil + 1; i++) { | |
331 skip_bits(gbc, 8); // skip additional bit stream info | |
332 } | |
333 } | |
334 | |
335 /* audio frame syntax flags, strategy data, and per-frame data */ | |
336 | |
337 if (s->num_blocks == 6) { | |
338 ac3_exponent_strategy = get_bits1(gbc); | |
339 parse_aht_info = get_bits1(gbc); | |
340 } else { | |
341 /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and | |
342 do not use AHT */ | |
343 ac3_exponent_strategy = 1; | |
344 parse_aht_info = 0; | |
345 } | |
346 | |
347 s->snr_offset_strategy = get_bits(gbc, 2); | |
348 parse_transient_proc_info = get_bits1(gbc); | |
349 | |
350 s->block_switch_syntax = get_bits1(gbc); | |
351 if (!s->block_switch_syntax) | |
352 memset(s->block_switch, 0, sizeof(s->block_switch)); | |
353 | |
354 s->dither_flag_syntax = get_bits1(gbc); | |
355 if (!s->dither_flag_syntax) { | |
356 for (ch = 1; ch <= s->fbw_channels; ch++) | |
357 s->dither_flag[ch] = 1; | |
358 } | |
359 s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0; | |
360 | |
361 s->bit_allocation_syntax = get_bits1(gbc); | |
362 if (!s->bit_allocation_syntax) { | |
363 /* set default bit allocation parameters */ | |
364 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2]; | |
365 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1]; | |
366 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1]; | |
367 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2]; | |
368 s->bit_alloc_params.floor = ff_ac3_floor_tab [7]; | |
369 } | |
370 | |
371 s->fast_gain_syntax = get_bits1(gbc); | |
372 s->dba_syntax = get_bits1(gbc); | |
373 s->skip_syntax = get_bits1(gbc); | |
374 parse_spx_atten_data = get_bits1(gbc); | |
375 | |
376 /* coupling strategy occurance and coupling use per block */ | |
377 num_cpl_blocks = 0; | |
378 if (s->channel_mode > 1) { | |
379 for (blk = 0; blk < s->num_blocks; blk++) { | |
380 s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc)); | |
381 if (s->cpl_strategy_exists[blk]) { | |
382 s->cpl_in_use[blk] = get_bits1(gbc); | |
383 } else { | |
384 s->cpl_in_use[blk] = s->cpl_in_use[blk-1]; | |
385 } | |
386 num_cpl_blocks += s->cpl_in_use[blk]; | |
387 } | |
388 } else { | |
389 memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use)); | |
390 } | |
391 | |
392 /* exponent strategy data */ | |
393 if (ac3_exponent_strategy) { | |
394 /* AC-3-style exponent strategy syntax */ | |
395 for (blk = 0; blk < s->num_blocks; blk++) { | |
396 for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) { | |
397 s->exp_strategy[blk][ch] = get_bits(gbc, 2); | |
398 } | |
399 } | |
400 } else { | |
401 /* LUT-based exponent strategy syntax */ | |
402 for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) { | |
7750
f9bd775992d4
merge declaration and init. variable is not used outside the loop.
jbr
parents:
7745
diff
changeset
|
403 int frmchexpstr = get_bits(gbc, 5); |
7745 | 404 for (blk = 0; blk < 6; blk++) { |
405 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk]; | |
406 } | |
407 } | |
408 } | |
409 /* LFE exponent strategy */ | |
410 if (s->lfe_on) { | |
411 for (blk = 0; blk < s->num_blocks; blk++) { | |
412 s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc); | |
413 } | |
414 } | |
415 /* original exponent strategies if this stream was converted from AC-3 */ | |
416 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && | |
417 (s->num_blocks == 6 || get_bits1(gbc))) { | |
7752
e3fb2606d5b5
skip converter exponent strategy for all channels at once
jbr
parents:
7750
diff
changeset
|
418 skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy |
7745 | 419 } |
420 | |
421 /* determine which channels use AHT */ | |
422 if (parse_aht_info) { | |
7755
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
423 /* For AHT to be used, all non-zero blocks must reuse exponents from |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
424 the first block. Furthermore, for AHT to be used in the coupling |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
425 channel, all blocks must use coupling and use the same coupling |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
426 strategy. */ |
7745 | 427 s->channel_uses_aht[CPL_CH]=0; |
428 for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) { | |
7755
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
429 int use_aht = 1; |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
430 for (blk = 1; blk < 6; blk++) { |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
431 if ((s->exp_strategy[blk][ch] != EXP_REUSE) || |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
432 (!ch && s->cpl_strategy_exists[blk])) { |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
433 use_aht = 0; |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
434 break; |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
435 } |
7745 | 436 } |
7755
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
437 s->channel_uses_aht[ch] = use_aht && get_bits1(gbc); |
7745 | 438 } |
439 } else { | |
440 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht)); | |
441 } | |
442 | |
443 /* per-frame SNR offset */ | |
444 if (!s->snr_offset_strategy) { | |
445 int csnroffst = (get_bits(gbc, 6) - 15) << 4; | |
446 int snroffst = (csnroffst + get_bits(gbc, 4)) << 2; | |
447 for (ch = 0; ch <= s->channels; ch++) | |
448 s->snr_offset[ch] = snroffst; | |
449 } | |
450 | |
451 /* transient pre-noise processing data */ | |
452 if (parse_transient_proc_info) { | |
453 for (ch = 1; ch <= s->fbw_channels; ch++) { | |
454 if (get_bits1(gbc)) { // channel in transient processing | |
455 skip_bits(gbc, 10); // skip transient processing location | |
456 skip_bits(gbc, 8); // skip transient processing length | |
457 } | |
458 } | |
459 } | |
460 | |
461 /* spectral extension attenuation data */ | |
462 if (parse_spx_atten_data) { | |
463 av_log_missing_feature(s->avctx, "Spectral extension attenuation", 1); | |
464 for (ch = 1; ch <= s->fbw_channels; ch++) { | |
465 if (get_bits1(gbc)) { // channel has spx attenuation | |
466 skip_bits(gbc, 5); // skip spx attenuation code | |
467 } | |
468 } | |
469 } | |
470 | |
471 /* block start information */ | |
472 if (s->num_blocks > 1 && get_bits1(gbc)) { | |
473 /* reference: Section E2.3.2.27 | |
474 nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame))) | |
475 The spec does not say what this data is or what it's used for. | |
476 It is likely the offset of each block within the frame. */ | |
477 int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2)); | |
478 skip_bits(gbc, block_start_bits); | |
479 } | |
480 | |
481 /* syntax state initialization */ | |
482 for (ch = 1; ch <= s->fbw_channels; ch++) { | |
483 s->first_cpl_coords[ch] = 1; | |
484 } | |
485 s->first_cpl_leak = 1; | |
486 | |
487 return 0; | |
488 } |