eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
[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 mant = get_sbits(gbc, bits-2+log_gain) << (26-log_gain-bits);
182 /* remap mantissa value to correct for asymmetric quantization */
183 if (mant >= 0)
184 b = 32768 >> (log_gain+8);
185 else
186 b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1];
187 mant += (ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (mant>>8) + b) >> 7;
188 } else {
189 /* small mantissa, no GAQ, or Gk=1 */
190 mant <<= 24 - bits;
191 if (!log_gain) {
192 /* remap mantissa value for no GAQ or Gk=1 */
193 mant += (ff_eac3_gaq_remap_1[hebap-8] * (mant>>8)) >> 7;
194 }
195 }
196 s->pre_mantissa[ch][bin][blk] = mant;
197 }
198 }
199 idct6(s->pre_mantissa[ch][bin]);
200 }
201 }
202
203 int ff_eac3_parse_header(AC3DecodeContext *s)
204 {
205 int i, blk, ch;
206 int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
207 int parse_transient_proc_info;
208 int num_cpl_blocks;
209 GetBitContext *gbc = &s->gbc;
210
211 /* An E-AC-3 stream can have multiple independent streams which the
212 application can select from. each independent stream can also contain
213 dependent streams which are used to add or replace channels. */
214 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
215 ff_log_missing_feature(s->avctx, "Dependent substream decoding", 1);
216 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
217 } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
218 av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
219 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
220 }
221
222 /* The substream id indicates which substream this frame belongs to. each
223 independent stream has its own substream id, and the dependent streams
224 associated to an independent stream have matching substream id's. */
225 if (s->substreamid) {
226 /* only decode substream with id=0. skip any additional substreams. */
227 ff_log_missing_feature(s->avctx, "Additional substreams", 1);
228 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
229 }
230
231 if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
232 /* The E-AC-3 specification does not tell how to handle reduced sample
233 rates in bit allocation. The best assumption would be that it is
234 handled like AC-3 DolbyNet, but we cannot be sure until we have a
235 sample which utilizes this feature. */
236 ff_log_missing_feature(s->avctx, "Reduced sampling rates", 1);
237 return -1;
238 }
239 skip_bits(gbc, 5); // skip bitstream id
240
241 /* volume control params */
242 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
243 skip_bits(gbc, 5); // skip dialog normalization
244 if (get_bits1(gbc)) {
245 skip_bits(gbc, 8); // skip compression gain word
246 }
247 }
248
249 /* dependent stream channel map */
250 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
251 if (get_bits1(gbc)) {
252 skip_bits(gbc, 16); // skip custom channel map
253 }
254 }
255
256 /* mixing metadata */
257 if (get_bits1(gbc)) {
258 /* center and surround mix levels */
259 if (s->channel_mode > AC3_CHMODE_STEREO) {
260 skip_bits(gbc, 2); // skip preferred stereo downmix mode
261 if (s->channel_mode & 1) {
262 /* if three front channels exist */
263 skip_bits(gbc, 3); //skip Lt/Rt center mix level
264 s->center_mix_level = get_bits(gbc, 3);
265 }
266 if (s->channel_mode & 4) {
267 /* if a surround channel exists */
268 skip_bits(gbc, 3); //skip Lt/Rt surround mix level
269 s->surround_mix_level = get_bits(gbc, 3);
270 }
271 }
272
273 /* lfe mix level */
274 if (s->lfe_on && get_bits1(gbc)) {
275 // TODO: use LFE mix level
276 skip_bits(gbc, 5); // skip LFE mix level code
277 }
278
279 /* info for mixing with other streams and substreams */
280 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
281 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
282 // TODO: apply program scale factor
283 if (get_bits1(gbc)) {
284 skip_bits(gbc, 6); // skip program scale factor
285 }
286 }
287 if (get_bits1(gbc)) {
288 skip_bits(gbc, 6); // skip external program scale factor
289 }
290 /* skip mixing parameter data */
291 switch(get_bits(gbc, 2)) {
292 case 1: skip_bits(gbc, 5); break;
293 case 2: skip_bits(gbc, 12); break;
294 case 3: {
295 int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
296 skip_bits_long(gbc, mix_data_size);
297 break;
298 }
299 }
300 /* skip pan information for mono or dual mono source */
301 if (s->channel_mode < AC3_CHMODE_STEREO) {
302 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
303 if (get_bits1(gbc)) {
304 /* note: this is not in the ATSC A/52B specification
305 reference: ETSI TS 102 366 V1.1.1
306 section: E.1.3.1.25 */
307 skip_bits(gbc, 8); // skip pan mean direction index
308 skip_bits(gbc, 6); // skip reserved paninfo bits
309 }
310 }
311 }
312 /* skip mixing configuration information */
313 if (get_bits1(gbc)) {
314 for (blk = 0; blk < s->num_blocks; blk++) {
315 if (s->num_blocks == 1 || get_bits1(gbc)) {
316 skip_bits(gbc, 5);
317 }
318 }
319 }
320 }
321 }
322
323 /* informational metadata */
324 if (get_bits1(gbc)) {
325 skip_bits(gbc, 3); // skip bit stream mode
326 skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
327 if (s->channel_mode == AC3_CHMODE_STEREO) {
328 skip_bits(gbc, 4); // skip Dolby surround and headphone mode
329 }
330 if (s->channel_mode >= AC3_CHMODE_2F2R) {
331 skip_bits(gbc, 2); // skip Dolby surround EX mode
332 }
333 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
334 if (get_bits1(gbc)) {
335 skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
336 }
337 }
338 if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
339 skip_bits1(gbc); // skip source sample rate code
340 }
341 }
342
343 /* converter synchronization flag
344 If frames are less than six blocks, this bit should be turned on
345 once every 6 blocks to indicate the start of a frame set.
346 reference: RFC 4598, Section 2.1.3 Frame Sets */
347 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
348 skip_bits1(gbc); // skip converter synchronization flag
349 }
350
351 /* original frame size code if this stream was converted from AC-3 */
352 if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
353 (s->num_blocks == 6 || get_bits1(gbc))) {
354 skip_bits(gbc, 6); // skip frame size code
355 }
356
357 /* additional bitstream info */
358 if (get_bits1(gbc)) {
359 int addbsil = get_bits(gbc, 6);
360 for (i = 0; i < addbsil + 1; i++) {
361 skip_bits(gbc, 8); // skip additional bit stream info
362 }
363 }
364
365 /* audio frame syntax flags, strategy data, and per-frame data */
366
367 if (s->num_blocks == 6) {
368 ac3_exponent_strategy = get_bits1(gbc);
369 parse_aht_info = get_bits1(gbc);
370 } else {
371 /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
372 do not use AHT */
373 ac3_exponent_strategy = 1;
374 parse_aht_info = 0;
375 }
376
377 s->snr_offset_strategy = get_bits(gbc, 2);
378 parse_transient_proc_info = get_bits1(gbc);
379
380 s->block_switch_syntax = get_bits1(gbc);
381 if (!s->block_switch_syntax)
382 memset(s->block_switch, 0, sizeof(s->block_switch));
383
384 s->dither_flag_syntax = get_bits1(gbc);
385 if (!s->dither_flag_syntax) {
386 for (ch = 1; ch <= s->fbw_channels; ch++)
387 s->dither_flag[ch] = 1;
388 }
389 s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
390
391 s->bit_allocation_syntax = get_bits1(gbc);
392 if (!s->bit_allocation_syntax) {
393 /* set default bit allocation parameters */
394 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
395 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
396 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1];
397 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
398 s->bit_alloc_params.floor = ff_ac3_floor_tab [7];
399 }
400
401 s->fast_gain_syntax = get_bits1(gbc);
402 s->dba_syntax = get_bits1(gbc);
403 s->skip_syntax = get_bits1(gbc);
404 parse_spx_atten_data = get_bits1(gbc);
405
406 /* coupling strategy occurance and coupling use per block */
407 num_cpl_blocks = 0;
408 if (s->channel_mode > 1) {
409 for (blk = 0; blk < s->num_blocks; blk++) {
410 s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
411 if (s->cpl_strategy_exists[blk]) {
412 s->cpl_in_use[blk] = get_bits1(gbc);
413 } else {
414 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
415 }
416 num_cpl_blocks += s->cpl_in_use[blk];
417 }
418 } else {
419 memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
420 }
421
422 /* exponent strategy data */
423 if (ac3_exponent_strategy) {
424 /* AC-3-style exponent strategy syntax */
425 for (blk = 0; blk < s->num_blocks; blk++) {
426 for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
427 s->exp_strategy[blk][ch] = get_bits(gbc, 2);
428 }
429 }
430 } else {
431 /* LUT-based exponent strategy syntax */
432 for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
433 int frmchexpstr = get_bits(gbc, 5);
434 for (blk = 0; blk < 6; blk++) {
435 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
436 }
437 }
438 }
439 /* LFE exponent strategy */
440 if (s->lfe_on) {
441 for (blk = 0; blk < s->num_blocks; blk++) {
442 s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
443 }
444 }
445 /* original exponent strategies if this stream was converted from AC-3 */
446 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
447 (s->num_blocks == 6 || get_bits1(gbc))) {
448 skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
449 }
450
451 /* determine which channels use AHT */
452 if (parse_aht_info) {
453 /* For AHT to be used, all non-zero blocks must reuse exponents from
454 the first block. Furthermore, for AHT to be used in the coupling
455 channel, all blocks must use coupling and use the same coupling
456 strategy. */
457 s->channel_uses_aht[CPL_CH]=0;
458 for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
459 int use_aht = 1;
460 for (blk = 1; blk < 6; blk++) {
461 if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
462 (!ch && s->cpl_strategy_exists[blk])) {
463 use_aht = 0;
464 break;
465 }
466 }
467 s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
468 }
469 } else {
470 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
471 }
472
473 /* per-frame SNR offset */
474 if (!s->snr_offset_strategy) {
475 int csnroffst = (get_bits(gbc, 6) - 15) << 4;
476 int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
477 for (ch = 0; ch <= s->channels; ch++)
478 s->snr_offset[ch] = snroffst;
479 }
480
481 /* transient pre-noise processing data */
482 if (parse_transient_proc_info) {
483 for (ch = 1; ch <= s->fbw_channels; ch++) {
484 if (get_bits1(gbc)) { // channel in transient processing
485 skip_bits(gbc, 10); // skip transient processing location
486 skip_bits(gbc, 8); // skip transient processing length
487 }
488 }
489 }
490
491 /* spectral extension attenuation data */
492 if (parse_spx_atten_data) {
493 ff_log_missing_feature(s->avctx, "Spectral extension attenuation", 1);
494 for (ch = 1; ch <= s->fbw_channels; ch++) {
495 if (get_bits1(gbc)) { // channel has spx attenuation
496 skip_bits(gbc, 5); // skip spx attenuation code
497 }
498 }
499 }
500
501 /* block start information */
502 if (s->num_blocks > 1 && get_bits1(gbc)) {
503 /* reference: Section E2.3.2.27
504 nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
505 The spec does not say what this data is or what it's used for.
506 It is likely the offset of each block within the frame. */
507 int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
508 skip_bits_long(gbc, block_start_bits);
509 ff_log_missing_feature(s->avctx, "Block start info", 1);
510 }
511
512 /* syntax state initialization */
513 for (ch = 1; ch <= s->fbw_channels; ch++) {
514 s->first_cpl_coords[ch] = 1;
515 }
516 s->first_cpl_leak = 1;
517
518 return 0;
519 }