always write footer partition according to specs
[libav.git] / libavcodec / eac3dec.c
CommitLineData
60203130
JR
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
0c3021ea 9 * modify it under the terms of the GNU Lesser General Public
60203130 10 * License as published by the Free Software Foundation; either
0c3021ea 11 * version 2.1 of the License, or (at your option) any later version.
60203130
JR
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
0c3021ea 16 * Lesser General Public License for more details.
60203130 17 *
0c3021ea 18 * You should have received a copy of the GNU Lesser General Public
60203130
JR
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 */
30typedef 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 */
52static 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}
d82bdf68
JR
81
82void 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++) {
9cf8ebe3 134 s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
d82bdf68
JR
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
173int 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 */
d82bdf68 402 for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
e1747bfa 403 int frmchexpstr = get_bits(gbc, 5);
d82bdf68
JR
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))) {
1ffbafa0 418 skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
d82bdf68
JR
419 }
420
421 /* determine which channels use AHT */
422 if (parse_aht_info) {
423 /* AHT is only available when there are 6 blocks in the frame.
424 The coupling channel can only use AHT when coupling is in use for
425 all blocks.
426 reference: Section E3.3.2 Bit Stream Helper Variables */
427 s->channel_uses_aht[CPL_CH]=0;
428 for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
429 int nchregs = 0;
430 for (blk = 0; blk < 6; blk++) {
431 if (ch)
432 nchregs += (s->exp_strategy[blk][ch] != EXP_REUSE);
433 else
434 nchregs += s->cpl_strategy_exists[blk] ||
435 (s->exp_strategy[blk][CPL_CH] != EXP_REUSE);
436 }
437 s->channel_uses_aht[ch] = (nchregs == 1) && get_bits1(gbc);
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}