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