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