Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | |
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 | /* | |
24 | * There are several features of E-AC-3 that this decoder does not yet support. | |
25 | * | |
26 | * Enhanced Coupling | |
27 | * No known samples exist. If any ever surface, this feature should not be | |
28 | * too difficult to implement. | |
29 | * | |
30 | * Reduced Sample Rates | |
31 | * No known samples exist. The spec also does not give clear information | |
32 | * on how this is to be implemented. | |
33 | * | |
34 | * Dependent Streams | |
35 | * Only the independent stream is currently decoded. Any dependent | |
36 | * streams are skipped. We have only come across two examples of this, and | |
37 | * they are both just test streams, one for HD-DVD and the other for | |
38 | * Blu-ray. | |
39 | * | |
40 | * Transient Pre-noise Processing | |
41 | * This is side information which a decoder should use to reduce artifacts | |
42 | * caused by transients. There are samples which are known to have this | |
43 | * information, but this decoder currently ignores it. | |
44 | */ | |
45 | ||
46 | ||
47 | #include "avcodec.h" | |
48 | #include "internal.h" | |
49 | #include "aac_ac3_parser.h" | |
50 | #include "ac3.h" | |
51 | #include "ac3_parser.h" | |
52 | #include "ac3dec.h" | |
53 | #include "ac3dec_data.h" | |
54 | #include "eac3_data.h" | |
55 | ||
56 | /** gain adaptive quantization mode */ | |
57 | typedef enum { | |
58 | EAC3_GAQ_NO =0, | |
59 | EAC3_GAQ_12, | |
60 | EAC3_GAQ_14, | |
61 | EAC3_GAQ_124 | |
62 | } EAC3GaqMode; | |
63 | ||
64 | #define EAC3_SR_CODE_REDUCED 3 | |
65 | ||
66 | void ff_eac3_apply_spectral_extension(AC3DecodeContext *s) | |
67 | { | |
68 | int bin, bnd, ch, i; | |
69 | uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS]; | |
70 | float rms_energy[SPX_MAX_BANDS]; | |
71 | ||
72 | /* Set copy index mapping table. Set wrap flags to apply a notch filter at | |
73 | wrap points later on. */ | |
74 | bin = s->spx_dst_start_freq; | |
75 | num_copy_sections = 0; | |
76 | for (bnd = 0; bnd < s->num_spx_bands; bnd++) { | |
77 | int copysize; | |
78 | int bandsize = s->spx_band_sizes[bnd]; | |
79 | if (bin + bandsize > s->spx_src_start_freq) { | |
80 | copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq; | |
81 | bin = s->spx_dst_start_freq; | |
82 | wrapflag[bnd] = 1; | |
83 | } | |
84 | for (i = 0; i < bandsize; i += copysize) { | |
85 | if (bin == s->spx_src_start_freq) { | |
86 | copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq; | |
87 | bin = s->spx_dst_start_freq; | |
88 | } | |
89 | copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin); | |
90 | bin += copysize; | |
91 | } | |
92 | } | |
93 | copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq; | |
94 | ||
95 | for (ch = 1; ch <= s->fbw_channels; ch++) { | |
96 | if (!s->channel_uses_spx[ch]) | |
97 | continue; | |
98 | ||
99 | /* Copy coeffs from normal bands to extension bands */ | |
100 | bin = s->spx_src_start_freq; | |
101 | for (i = 0; i < num_copy_sections; i++) { | |
102 | memcpy(&s->transform_coeffs[ch][bin], | |
103 | &s->transform_coeffs[ch][s->spx_dst_start_freq], | |
104 | copy_sizes[i]*sizeof(float)); | |
105 | bin += copy_sizes[i]; | |
106 | } | |
107 | ||
108 | /* Calculate RMS energy for each SPX band. */ | |
109 | bin = s->spx_src_start_freq; | |
110 | for (bnd = 0; bnd < s->num_spx_bands; bnd++) { | |
111 | int bandsize = s->spx_band_sizes[bnd]; | |
112 | float accum = 0.0f; | |
113 | for (i = 0; i < bandsize; i++) { | |
114 | float coeff = s->transform_coeffs[ch][bin++]; | |
115 | accum += coeff * coeff; | |
116 | } | |
117 | rms_energy[bnd] = sqrtf(accum / bandsize); | |
118 | } | |
119 | ||
120 | /* Apply a notch filter at transitions between normal and extension | |
121 | bands and at all wrap points. */ | |
122 | if (s->spx_atten_code[ch] >= 0) { | |
123 | const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]]; | |
124 | bin = s->spx_src_start_freq - 2; | |
125 | for (bnd = 0; bnd < s->num_spx_bands; bnd++) { | |
126 | if (wrapflag[bnd]) { | |
127 | float *coeffs = &s->transform_coeffs[ch][bin]; | |
128 | coeffs[0] *= atten_tab[0]; | |
129 | coeffs[1] *= atten_tab[1]; | |
130 | coeffs[2] *= atten_tab[2]; | |
131 | coeffs[3] *= atten_tab[1]; | |
132 | coeffs[4] *= atten_tab[0]; | |
133 | } | |
134 | bin += s->spx_band_sizes[bnd]; | |
135 | } | |
136 | } | |
137 | ||
138 | /* Apply noise-blended coefficient scaling based on previously | |
139 | calculated RMS energy, blending factors, and SPX coordinates for | |
140 | each band. */ | |
141 | bin = s->spx_src_start_freq; | |
142 | for (bnd = 0; bnd < s->num_spx_bands; bnd++) { | |
143 | float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN); | |
144 | float sscale = s->spx_signal_blend[ch][bnd]; | |
145 | for (i = 0; i < s->spx_band_sizes[bnd]; i++) { | |
146 | float noise = nscale * (int32_t)av_lfg_get(&s->dith_state); | |
147 | s->transform_coeffs[ch][bin] *= sscale; | |
148 | s->transform_coeffs[ch][bin++] += noise; | |
149 | } | |
150 | } | |
151 | } | |
152 | } | |
153 | ||
154 | ||
155 | /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */ | |
156 | #define COEFF_0 10273905LL | |
157 | ||
158 | /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */ | |
159 | #define COEFF_1 11863283LL | |
160 | ||
161 | /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */ | |
162 | #define COEFF_2 3070444LL | |
163 | ||
164 | /** | |
165 | * Calculate 6-point IDCT of the pre-mantissas. | |
166 | * All calculations are 24-bit fixed-point. | |
167 | */ | |
168 | static void idct6(int pre_mant[6]) | |
169 | { | |
170 | int tmp; | |
171 | int even0, even1, even2, odd0, odd1, odd2; | |
172 | ||
173 | odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5]; | |
174 | ||
175 | even2 = ( pre_mant[2] * COEFF_0) >> 23; | |
176 | tmp = ( pre_mant[4] * COEFF_1) >> 23; | |
177 | odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23; | |
178 | ||
179 | even0 = pre_mant[0] + (tmp >> 1); | |
180 | even1 = pre_mant[0] - tmp; | |
181 | ||
182 | tmp = even0; | |
183 | even0 = tmp + even2; | |
184 | even2 = tmp - even2; | |
185 | ||
186 | tmp = odd0; | |
187 | odd0 = tmp + pre_mant[1] + pre_mant[3]; | |
188 | odd2 = tmp + pre_mant[5] - pre_mant[3]; | |
189 | ||
190 | pre_mant[0] = even0 + odd0; | |
191 | pre_mant[1] = even1 + odd1; | |
192 | pre_mant[2] = even2 + odd2; | |
193 | pre_mant[3] = even2 - odd2; | |
194 | pre_mant[4] = even1 - odd1; | |
195 | pre_mant[5] = even0 - odd0; | |
196 | } | |
197 | ||
198 | void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch) | |
199 | { | |
200 | int bin, blk, gs; | |
201 | int end_bap, gaq_mode; | |
202 | GetBitContext *gbc = &s->gbc; | |
203 | int gaq_gain[AC3_MAX_COEFS]; | |
204 | ||
205 | gaq_mode = get_bits(gbc, 2); | |
206 | end_bap = (gaq_mode < 2) ? 12 : 17; | |
207 | ||
208 | /* if GAQ gain is used, decode gain codes for bins with hebap between | |
209 | 8 and end_bap */ | |
210 | gs = 0; | |
211 | if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) { | |
212 | /* read 1-bit GAQ gain codes */ | |
213 | for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { | |
214 | if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap) | |
215 | gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1); | |
216 | } | |
217 | } else if (gaq_mode == EAC3_GAQ_124) { | |
218 | /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */ | |
219 | int gc = 2; | |
220 | for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { | |
221 | if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) { | |
222 | if (gc++ == 2) { | |
223 | int group_code = get_bits(gbc, 5); | |
224 | if (group_code > 26) { | |
225 | av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n"); | |
226 | group_code = 26; | |
227 | } | |
228 | gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0]; | |
229 | gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1]; | |
230 | gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2]; | |
231 | gc = 0; | |
232 | } | |
233 | } | |
234 | } | |
235 | } | |
236 | ||
237 | gs=0; | |
238 | for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { | |
239 | int hebap = s->bap[ch][bin]; | |
240 | int bits = ff_eac3_bits_vs_hebap[hebap]; | |
241 | if (!hebap) { | |
242 | /* zero-mantissa dithering */ | |
243 | for (blk = 0; blk < 6; blk++) { | |
244 | s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000; | |
245 | } | |
246 | } else if (hebap < 8) { | |
247 | /* Vector Quantization */ | |
248 | int v = get_bits(gbc, bits); | |
249 | for (blk = 0; blk < 6; blk++) { | |
250 | s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8; | |
251 | } | |
252 | } else { | |
253 | /* Gain Adaptive Quantization */ | |
254 | int gbits, log_gain; | |
255 | if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) { | |
256 | log_gain = gaq_gain[gs++]; | |
257 | } else { | |
258 | log_gain = 0; | |
259 | } | |
260 | gbits = bits - log_gain; | |
261 | ||
262 | for (blk = 0; blk < 6; blk++) { | |
263 | int mant = get_sbits(gbc, gbits); | |
264 | if (log_gain && mant == -(1 << (gbits-1))) { | |
265 | /* large mantissa */ | |
266 | int b; | |
267 | int mbits = bits - (2 - log_gain); | |
268 | mant = get_sbits(gbc, mbits); | |
269 | mant <<= (23 - (mbits - 1)); | |
270 | /* remap mantissa value to correct for asymmetric quantization */ | |
271 | if (mant >= 0) | |
272 | b = 1 << (23 - log_gain); | |
273 | else | |
274 | b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8; | |
275 | mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b; | |
276 | } else { | |
277 | /* small mantissa, no GAQ, or Gk=1 */ | |
278 | mant <<= 24 - bits; | |
279 | if (!log_gain) { | |
280 | /* remap mantissa value for no GAQ or Gk=1 */ | |
281 | mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15; | |
282 | } | |
283 | } | |
284 | s->pre_mantissa[ch][bin][blk] = mant; | |
285 | } | |
286 | } | |
287 | idct6(s->pre_mantissa[ch][bin]); | |
288 | } | |
289 | } | |
290 | ||
291 | int ff_eac3_parse_header(AC3DecodeContext *s) | |
292 | { | |
293 | int i, blk, ch; | |
294 | int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data; | |
295 | int parse_transient_proc_info; | |
296 | int num_cpl_blocks; | |
297 | GetBitContext *gbc = &s->gbc; | |
298 | ||
299 | /* An E-AC-3 stream can have multiple independent streams which the | |
300 | application can select from. each independent stream can also contain | |
301 | dependent streams which are used to add or replace channels. */ | |
302 | if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) { | |
303 | avpriv_request_sample(s->avctx, "Dependent substream decoding"); | |
304 | return AAC_AC3_PARSE_ERROR_FRAME_TYPE; | |
305 | } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) { | |
306 | av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n"); | |
307 | return AAC_AC3_PARSE_ERROR_FRAME_TYPE; | |
308 | } | |
309 | ||
310 | /* The substream id indicates which substream this frame belongs to. each | |
311 | independent stream has its own substream id, and the dependent streams | |
312 | associated to an independent stream have matching substream id's. */ | |
313 | if (s->substreamid) { | |
314 | /* only decode substream with id=0. skip any additional substreams. */ | |
315 | avpriv_request_sample(s->avctx, "Additional substreams"); | |
316 | return AAC_AC3_PARSE_ERROR_FRAME_TYPE; | |
317 | } | |
318 | ||
319 | if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) { | |
320 | /* The E-AC-3 specification does not tell how to handle reduced sample | |
321 | rates in bit allocation. The best assumption would be that it is | |
322 | handled like AC-3 DolbyNet, but we cannot be sure until we have a | |
323 | sample which utilizes this feature. */ | |
324 | avpriv_request_sample(s->avctx, "Reduced sampling rate"); | |
325 | return AVERROR_PATCHWELCOME; | |
326 | } | |
327 | skip_bits(gbc, 5); // skip bitstream id | |
328 | ||
329 | /* volume control params */ | |
330 | for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
331 | skip_bits(gbc, 5); // skip dialog normalization | |
332 | if (get_bits1(gbc)) { | |
333 | skip_bits(gbc, 8); // skip compression gain word | |
334 | } | |
335 | } | |
336 | ||
337 | /* dependent stream channel map */ | |
338 | if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) { | |
339 | if (get_bits1(gbc)) { | |
340 | skip_bits(gbc, 16); // skip custom channel map | |
341 | } | |
342 | } | |
343 | ||
344 | /* mixing metadata */ | |
345 | if (get_bits1(gbc)) { | |
346 | /* center and surround mix levels */ | |
347 | if (s->channel_mode > AC3_CHMODE_STEREO) { | |
348 | s->preferred_downmix = get_bits(gbc, 2); | |
349 | if (s->channel_mode & 1) { | |
350 | /* if three front channels exist */ | |
351 | s->center_mix_level_ltrt = get_bits(gbc, 3); | |
352 | s->center_mix_level = get_bits(gbc, 3); | |
353 | } | |
354 | if (s->channel_mode & 4) { | |
355 | /* if a surround channel exists */ | |
356 | s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7); | |
357 | s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7); | |
358 | } | |
359 | } | |
360 | ||
361 | /* lfe mix level */ | |
362 | if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) { | |
363 | s->lfe_mix_level = get_bits(gbc, 5); | |
364 | } | |
365 | ||
366 | /* info for mixing with other streams and substreams */ | |
367 | if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) { | |
368 | for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
369 | // TODO: apply program scale factor | |
370 | if (get_bits1(gbc)) { | |
371 | skip_bits(gbc, 6); // skip program scale factor | |
372 | } | |
373 | } | |
374 | if (get_bits1(gbc)) { | |
375 | skip_bits(gbc, 6); // skip external program scale factor | |
376 | } | |
377 | /* skip mixing parameter data */ | |
378 | switch(get_bits(gbc, 2)) { | |
379 | case 1: skip_bits(gbc, 5); break; | |
380 | case 2: skip_bits(gbc, 12); break; | |
381 | case 3: { | |
382 | int mix_data_size = (get_bits(gbc, 5) + 2) << 3; | |
383 | skip_bits_long(gbc, mix_data_size); | |
384 | break; | |
385 | } | |
386 | } | |
387 | /* skip pan information for mono or dual mono source */ | |
388 | if (s->channel_mode < AC3_CHMODE_STEREO) { | |
389 | for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
390 | if (get_bits1(gbc)) { | |
391 | /* note: this is not in the ATSC A/52B specification | |
392 | reference: ETSI TS 102 366 V1.1.1 | |
393 | section: E.1.3.1.25 */ | |
394 | skip_bits(gbc, 8); // skip pan mean direction index | |
395 | skip_bits(gbc, 6); // skip reserved paninfo bits | |
396 | } | |
397 | } | |
398 | } | |
399 | /* skip mixing configuration information */ | |
400 | if (get_bits1(gbc)) { | |
401 | for (blk = 0; blk < s->num_blocks; blk++) { | |
402 | if (s->num_blocks == 1 || get_bits1(gbc)) { | |
403 | skip_bits(gbc, 5); | |
404 | } | |
405 | } | |
406 | } | |
407 | } | |
408 | } | |
409 | ||
410 | /* informational metadata */ | |
411 | if (get_bits1(gbc)) { | |
412 | s->bitstream_mode = get_bits(gbc, 3); | |
413 | skip_bits(gbc, 2); // skip copyright bit and original bitstream bit | |
414 | if (s->channel_mode == AC3_CHMODE_STEREO) { | |
415 | s->dolby_surround_mode = get_bits(gbc, 2); | |
416 | s->dolby_headphone_mode = get_bits(gbc, 2); | |
417 | } | |
418 | if (s->channel_mode >= AC3_CHMODE_2F2R) { | |
419 | s->dolby_surround_ex_mode = get_bits(gbc, 2); | |
420 | } | |
421 | for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { | |
422 | if (get_bits1(gbc)) { | |
423 | skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type | |
424 | } | |
425 | } | |
426 | if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) { | |
427 | skip_bits1(gbc); // skip source sample rate code | |
428 | } | |
429 | } | |
430 | ||
431 | /* converter synchronization flag | |
432 | If frames are less than six blocks, this bit should be turned on | |
433 | once every 6 blocks to indicate the start of a frame set. | |
434 | reference: RFC 4598, Section 2.1.3 Frame Sets */ | |
435 | if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) { | |
436 | skip_bits1(gbc); // skip converter synchronization flag | |
437 | } | |
438 | ||
439 | /* original frame size code if this stream was converted from AC-3 */ | |
440 | if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT && | |
441 | (s->num_blocks == 6 || get_bits1(gbc))) { | |
442 | skip_bits(gbc, 6); // skip frame size code | |
443 | } | |
444 | ||
445 | /* additional bitstream info */ | |
446 | if (get_bits1(gbc)) { | |
447 | int addbsil = get_bits(gbc, 6); | |
448 | for (i = 0; i < addbsil + 1; i++) { | |
449 | skip_bits(gbc, 8); // skip additional bit stream info | |
450 | } | |
451 | } | |
452 | ||
453 | /* audio frame syntax flags, strategy data, and per-frame data */ | |
454 | ||
455 | if (s->num_blocks == 6) { | |
456 | ac3_exponent_strategy = get_bits1(gbc); | |
457 | parse_aht_info = get_bits1(gbc); | |
458 | } else { | |
459 | /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and | |
460 | do not use AHT */ | |
461 | ac3_exponent_strategy = 1; | |
462 | parse_aht_info = 0; | |
463 | } | |
464 | ||
465 | s->snr_offset_strategy = get_bits(gbc, 2); | |
466 | parse_transient_proc_info = get_bits1(gbc); | |
467 | ||
468 | s->block_switch_syntax = get_bits1(gbc); | |
469 | if (!s->block_switch_syntax) | |
470 | memset(s->block_switch, 0, sizeof(s->block_switch)); | |
471 | ||
472 | s->dither_flag_syntax = get_bits1(gbc); | |
473 | if (!s->dither_flag_syntax) { | |
474 | for (ch = 1; ch <= s->fbw_channels; ch++) | |
475 | s->dither_flag[ch] = 1; | |
476 | } | |
477 | s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0; | |
478 | ||
479 | s->bit_allocation_syntax = get_bits1(gbc); | |
480 | if (!s->bit_allocation_syntax) { | |
481 | /* set default bit allocation parameters */ | |
482 | s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2]; | |
483 | s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1]; | |
484 | s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1]; | |
485 | s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2]; | |
486 | s->bit_alloc_params.floor = ff_ac3_floor_tab [7]; | |
487 | } | |
488 | ||
489 | s->fast_gain_syntax = get_bits1(gbc); | |
490 | s->dba_syntax = get_bits1(gbc); | |
491 | s->skip_syntax = get_bits1(gbc); | |
492 | parse_spx_atten_data = get_bits1(gbc); | |
493 | ||
494 | /* coupling strategy occurrence and coupling use per block */ | |
495 | num_cpl_blocks = 0; | |
496 | if (s->channel_mode > 1) { | |
497 | for (blk = 0; blk < s->num_blocks; blk++) { | |
498 | s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc)); | |
499 | if (s->cpl_strategy_exists[blk]) { | |
500 | s->cpl_in_use[blk] = get_bits1(gbc); | |
501 | } else { | |
502 | s->cpl_in_use[blk] = s->cpl_in_use[blk-1]; | |
503 | } | |
504 | num_cpl_blocks += s->cpl_in_use[blk]; | |
505 | } | |
506 | } else { | |
507 | memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use)); | |
508 | } | |
509 | ||
510 | /* exponent strategy data */ | |
511 | if (ac3_exponent_strategy) { | |
512 | /* AC-3-style exponent strategy syntax */ | |
513 | for (blk = 0; blk < s->num_blocks; blk++) { | |
514 | for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) { | |
515 | s->exp_strategy[blk][ch] = get_bits(gbc, 2); | |
516 | } | |
517 | } | |
518 | } else { | |
519 | /* LUT-based exponent strategy syntax */ | |
520 | for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) { | |
521 | int frmchexpstr = get_bits(gbc, 5); | |
522 | for (blk = 0; blk < 6; blk++) { | |
523 | s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk]; | |
524 | } | |
525 | } | |
526 | } | |
527 | /* LFE exponent strategy */ | |
528 | if (s->lfe_on) { | |
529 | for (blk = 0; blk < s->num_blocks; blk++) { | |
530 | s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc); | |
531 | } | |
532 | } | |
533 | /* original exponent strategies if this stream was converted from AC-3 */ | |
534 | if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && | |
535 | (s->num_blocks == 6 || get_bits1(gbc))) { | |
536 | skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy | |
537 | } | |
538 | ||
539 | /* determine which channels use AHT */ | |
540 | if (parse_aht_info) { | |
541 | /* For AHT to be used, all non-zero blocks must reuse exponents from | |
542 | the first block. Furthermore, for AHT to be used in the coupling | |
543 | channel, all blocks must use coupling and use the same coupling | |
544 | strategy. */ | |
545 | s->channel_uses_aht[CPL_CH]=0; | |
546 | for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) { | |
547 | int use_aht = 1; | |
548 | for (blk = 1; blk < 6; blk++) { | |
549 | if ((s->exp_strategy[blk][ch] != EXP_REUSE) || | |
550 | (!ch && s->cpl_strategy_exists[blk])) { | |
551 | use_aht = 0; | |
552 | break; | |
553 | } | |
554 | } | |
555 | s->channel_uses_aht[ch] = use_aht && get_bits1(gbc); | |
556 | } | |
557 | } else { | |
558 | memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht)); | |
559 | } | |
560 | ||
561 | /* per-frame SNR offset */ | |
562 | if (!s->snr_offset_strategy) { | |
563 | int csnroffst = (get_bits(gbc, 6) - 15) << 4; | |
564 | int snroffst = (csnroffst + get_bits(gbc, 4)) << 2; | |
565 | for (ch = 0; ch <= s->channels; ch++) | |
566 | s->snr_offset[ch] = snroffst; | |
567 | } | |
568 | ||
569 | /* transient pre-noise processing data */ | |
570 | if (parse_transient_proc_info) { | |
571 | for (ch = 1; ch <= s->fbw_channels; ch++) { | |
572 | if (get_bits1(gbc)) { // channel in transient processing | |
573 | skip_bits(gbc, 10); // skip transient processing location | |
574 | skip_bits(gbc, 8); // skip transient processing length | |
575 | } | |
576 | } | |
577 | } | |
578 | ||
579 | /* spectral extension attenuation data */ | |
580 | for (ch = 1; ch <= s->fbw_channels; ch++) { | |
581 | if (parse_spx_atten_data && get_bits1(gbc)) { | |
582 | s->spx_atten_code[ch] = get_bits(gbc, 5); | |
583 | } else { | |
584 | s->spx_atten_code[ch] = -1; | |
585 | } | |
586 | } | |
587 | ||
588 | /* block start information */ | |
589 | if (s->num_blocks > 1 && get_bits1(gbc)) { | |
590 | /* reference: Section E2.3.2.27 | |
591 | nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame))) | |
592 | The spec does not say what this data is or what it's used for. | |
593 | It is likely the offset of each block within the frame. */ | |
594 | int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2)); | |
595 | skip_bits_long(gbc, block_start_bits); | |
596 | avpriv_request_sample(s->avctx, "Block start info"); | |
597 | } | |
598 | ||
599 | /* syntax state initialization */ | |
600 | for (ch = 1; ch <= s->fbw_channels; ch++) { | |
601 | s->first_spx_coords[ch] = 1; | |
602 | s->first_cpl_coords[ch] = 1; | |
603 | } | |
604 | s->first_cpl_leak = 1; | |
605 | ||
606 | return 0; | |
607 | } |