3 * Copyright (c) 2007 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
4 * Copyright (c) 2008 Justin Ruggles
6 * This file is part of Libav.
8 * Libav 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.
13 * Libav 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.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * There are several features of E-AC-3 that this decoder does not yet support.
27 * No known samples exist. If any ever surface, this feature should not be
28 * too difficult to implement.
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.
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
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.
49 #include "aac_ac3_parser.h"
52 #include "ac3dec_data.h"
53 #include "eac3_data.h"
55 /** gain adaptive quantization mode */
63 #define EAC3_SR_CODE_REDUCED 3
65 void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
68 uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];
69 float rms_energy[SPX_MAX_BANDS];
71 /* Set copy index mapping table. Set wrap flags to apply a notch filter at
72 wrap points later on. */
73 bin = s->spx_dst_start_freq;
74 num_copy_sections = 0;
75 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
77 int bandsize = s->spx_band_sizes[bnd];
78 if (bin + bandsize > s->spx_src_start_freq) {
79 copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
80 bin = s->spx_dst_start_freq;
83 for (i = 0; i < bandsize; i += copysize) {
84 if (bin == s->spx_src_start_freq) {
85 copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
86 bin = s->spx_dst_start_freq;
88 copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);
92 copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
94 for (ch = 1; ch <= s->fbw_channels; ch++) {
95 if (!s->channel_uses_spx[ch])
98 /* Copy coeffs from normal bands to extension bands */
99 bin = s->spx_src_start_freq;
100 for (i = 0; i < num_copy_sections; i++) {
101 memcpy(&s->transform_coeffs[ch][bin],
102 &s->transform_coeffs[ch][s->spx_dst_start_freq],
103 copy_sizes[i]*sizeof(float));
104 bin += copy_sizes[i];
107 /* Calculate RMS energy for each SPX band. */
108 bin = s->spx_src_start_freq;
109 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
110 int bandsize = s->spx_band_sizes[bnd];
112 for (i = 0; i < bandsize; i++) {
113 float coeff = s->transform_coeffs[ch][bin++];
114 accum += coeff * coeff;
116 rms_energy[bnd] = sqrtf(accum / bandsize);
119 /* Apply a notch filter at transitions between normal and extension
120 bands and at all wrap points. */
121 if (s->spx_atten_code[ch] >= 0) {
122 const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];
123 bin = s->spx_src_start_freq - 2;
124 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
126 float *coeffs = &s->transform_coeffs[ch][bin];
127 coeffs[0] *= atten_tab[0];
128 coeffs[1] *= atten_tab[1];
129 coeffs[2] *= atten_tab[2];
130 coeffs[3] *= atten_tab[1];
131 coeffs[4] *= atten_tab[0];
133 bin += s->spx_band_sizes[bnd];
137 /* Apply noise-blended coefficient scaling based on previously
138 calculated RMS energy, blending factors, and SPX coordinates for
140 bin = s->spx_src_start_freq;
141 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
142 float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN);
143 float sscale = s->spx_signal_blend[ch][bnd];
144 for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
145 float noise = nscale * (int32_t)av_lfg_get(&s->dith_state);
146 s->transform_coeffs[ch][bin] *= sscale;
147 s->transform_coeffs[ch][bin++] += noise;
154 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
155 #define COEFF_0 10273905LL
157 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */
158 #define COEFF_1 11863283LL
160 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */
161 #define COEFF_2 3070444LL
164 * Calculate 6-point IDCT of the pre-mantissas.
165 * All calculations are 24-bit fixed-point.
167 static void idct6(int pre_mant[6])
170 int even0, even1, even2, odd0, odd1, odd2;
172 odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
174 even2 = ( pre_mant[2] * COEFF_0) >> 23;
175 tmp = ( pre_mant[4] * COEFF_1) >> 23;
176 odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
178 even0 = pre_mant[0] + (tmp >> 1);
179 even1 = pre_mant[0] - tmp;
186 odd0 = tmp + pre_mant[1] + pre_mant[3];
187 odd2 = tmp + pre_mant[5] - pre_mant[3];
189 pre_mant[0] = even0 + odd0;
190 pre_mant[1] = even1 + odd1;
191 pre_mant[2] = even2 + odd2;
192 pre_mant[3] = even2 - odd2;
193 pre_mant[4] = even1 - odd1;
194 pre_mant[5] = even0 - odd0;
197 void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
200 int end_bap, gaq_mode;
201 GetBitContext *gbc = &s->gbc;
202 int gaq_gain[AC3_MAX_COEFS];
204 gaq_mode = get_bits(gbc, 2);
205 end_bap = (gaq_mode < 2) ? 12 : 17;
207 /* if GAQ gain is used, decode gain codes for bins with hebap between
210 if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
211 /* read 1-bit GAQ gain codes */
212 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
213 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
214 gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
216 } else if (gaq_mode == EAC3_GAQ_124) {
217 /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
219 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
220 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
222 int group_code = get_bits(gbc, 5);
223 if (group_code > 26) {
224 av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
227 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
228 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
229 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
237 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
238 int hebap = s->bap[ch][bin];
239 int bits = ff_eac3_bits_vs_hebap[hebap];
241 /* zero-mantissa dithering */
242 for (blk = 0; blk < 6; blk++) {
243 s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
245 } else if (hebap < 8) {
246 /* Vector Quantization */
247 int v = get_bits(gbc, bits);
248 for (blk = 0; blk < 6; blk++) {
249 s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
252 /* Gain Adaptive Quantization */
254 if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
255 log_gain = gaq_gain[gs++];
259 gbits = bits - log_gain;
261 for (blk = 0; blk < 6; blk++) {
262 int mant = get_sbits(gbc, gbits);
263 if (log_gain && mant == -(1 << (gbits-1))) {
266 int mbits = bits - (2 - log_gain);
267 mant = get_sbits(gbc, mbits);
268 mant <<= (23 - (mbits - 1));
269 /* remap mantissa value to correct for asymmetric quantization */
271 b = 1 << (23 - log_gain);
273 b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8;
274 mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
276 /* small mantissa, no GAQ, or Gk=1 */
279 /* remap mantissa value for no GAQ or Gk=1 */
280 mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
283 s->pre_mantissa[ch][bin][blk] = mant;
286 idct6(s->pre_mantissa[ch][bin]);
290 int ff_eac3_parse_header(AC3DecodeContext *s)
293 int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
294 int parse_transient_proc_info;
296 GetBitContext *gbc = &s->gbc;
298 /* An E-AC-3 stream can have multiple independent streams which the
299 application can select from. each independent stream can also contain
300 dependent streams which are used to add or replace channels. */
301 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
302 if (!s->eac3_frame_dependent_found) {
303 s->eac3_frame_dependent_found = 1;
304 avpriv_request_sample(s->avctx, "Dependent substream decoding");
306 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
307 } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
308 av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
309 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
312 /* The substream id indicates which substream this frame belongs to. each
313 independent stream has its own substream id, and the dependent streams
314 associated to an independent stream have matching substream id's. */
315 if (s->substreamid) {
316 /* only decode substream with id=0. skip any additional substreams. */
317 if (!s->eac3_subsbtreamid_found) {
318 s->eac3_subsbtreamid_found = 1;
319 avpriv_request_sample(s->avctx, "Additional substreams");
321 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
324 if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
325 /* The E-AC-3 specification does not tell how to handle reduced sample
326 rates in bit allocation. The best assumption would be that it is
327 handled like AC-3 DolbyNet, but we cannot be sure until we have a
328 sample which utilizes this feature. */
329 avpriv_request_sample(s->avctx, "Reduced sampling rate");
330 return AVERROR_PATCHWELCOME;
332 skip_bits(gbc, 5); // skip bitstream id
334 /* volume control params */
335 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
336 skip_bits(gbc, 5); // skip dialog normalization
337 if (get_bits1(gbc)) {
338 skip_bits(gbc, 8); // skip compression gain word
342 /* dependent stream channel map */
343 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
344 if (get_bits1(gbc)) {
345 skip_bits(gbc, 16); // skip custom channel map
349 /* mixing metadata */
350 if (get_bits1(gbc)) {
351 /* center and surround mix levels */
352 if (s->channel_mode > AC3_CHMODE_STEREO) {
353 s->preferred_downmix = get_bits(gbc, 2);
354 if (s->channel_mode & 1) {
355 /* if three front channels exist */
356 s->center_mix_level_ltrt = get_bits(gbc, 3);
357 s->center_mix_level = get_bits(gbc, 3);
359 if (s->channel_mode & 4) {
360 /* if a surround channel exists */
361 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
362 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
367 if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) {
368 s->lfe_mix_level = get_bits(gbc, 5);
371 /* info for mixing with other streams and substreams */
372 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
373 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
374 // TODO: apply program scale factor
375 if (get_bits1(gbc)) {
376 skip_bits(gbc, 6); // skip program scale factor
379 if (get_bits1(gbc)) {
380 skip_bits(gbc, 6); // skip external program scale factor
382 /* skip mixing parameter data */
383 switch(get_bits(gbc, 2)) {
384 case 1: skip_bits(gbc, 5); break;
385 case 2: skip_bits(gbc, 12); break;
387 int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
388 skip_bits_long(gbc, mix_data_size);
392 /* skip pan information for mono or dual mono source */
393 if (s->channel_mode < AC3_CHMODE_STEREO) {
394 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
395 if (get_bits1(gbc)) {
396 /* note: this is not in the ATSC A/52B specification
397 reference: ETSI TS 102 366 V1.1.1
398 section: E.1.3.1.25 */
399 skip_bits(gbc, 8); // skip pan mean direction index
400 skip_bits(gbc, 6); // skip reserved paninfo bits
404 /* skip mixing configuration information */
405 if (get_bits1(gbc)) {
406 for (blk = 0; blk < s->num_blocks; blk++) {
407 if (s->num_blocks == 1 || get_bits1(gbc)) {
415 /* informational metadata */
416 if (get_bits1(gbc)) {
417 s->bitstream_mode = get_bits(gbc, 3);
418 skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
419 if (s->channel_mode == AC3_CHMODE_STEREO) {
420 s->dolby_surround_mode = get_bits(gbc, 2);
421 s->dolby_headphone_mode = get_bits(gbc, 2);
423 if (s->channel_mode >= AC3_CHMODE_2F2R) {
424 s->dolby_surround_ex_mode = get_bits(gbc, 2);
426 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
427 if (get_bits1(gbc)) {
428 skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
431 if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
432 skip_bits1(gbc); // skip source sample rate code
436 /* converter synchronization flag
437 If frames are less than six blocks, this bit should be turned on
438 once every 6 blocks to indicate the start of a frame set.
439 reference: RFC 4598, Section 2.1.3 Frame Sets */
440 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
441 skip_bits1(gbc); // skip converter synchronization flag
444 /* original frame size code if this stream was converted from AC-3 */
445 if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
446 (s->num_blocks == 6 || get_bits1(gbc))) {
447 skip_bits(gbc, 6); // skip frame size code
450 /* additional bitstream info */
451 if (get_bits1(gbc)) {
452 int addbsil = get_bits(gbc, 6);
453 for (i = 0; i < addbsil + 1; i++) {
454 skip_bits(gbc, 8); // skip additional bit stream info
458 /* audio frame syntax flags, strategy data, and per-frame data */
460 if (s->num_blocks == 6) {
461 ac3_exponent_strategy = get_bits1(gbc);
462 parse_aht_info = get_bits1(gbc);
464 /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
466 ac3_exponent_strategy = 1;
470 s->snr_offset_strategy = get_bits(gbc, 2);
471 parse_transient_proc_info = get_bits1(gbc);
473 s->block_switch_syntax = get_bits1(gbc);
474 if (!s->block_switch_syntax)
475 memset(s->block_switch, 0, sizeof(s->block_switch));
477 s->dither_flag_syntax = get_bits1(gbc);
478 if (!s->dither_flag_syntax) {
479 for (ch = 1; ch <= s->fbw_channels; ch++)
480 s->dither_flag[ch] = 1;
482 s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
484 s->bit_allocation_syntax = get_bits1(gbc);
485 if (!s->bit_allocation_syntax) {
486 /* set default bit allocation parameters */
487 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
488 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
489 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1];
490 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
491 s->bit_alloc_params.floor = ff_ac3_floor_tab [7];
494 s->fast_gain_syntax = get_bits1(gbc);
495 s->dba_syntax = get_bits1(gbc);
496 s->skip_syntax = get_bits1(gbc);
497 parse_spx_atten_data = get_bits1(gbc);
499 /* coupling strategy occurrence and coupling use per block */
501 if (s->channel_mode > 1) {
502 for (blk = 0; blk < s->num_blocks; blk++) {
503 s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
504 if (s->cpl_strategy_exists[blk]) {
505 s->cpl_in_use[blk] = get_bits1(gbc);
507 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
509 num_cpl_blocks += s->cpl_in_use[blk];
512 memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
515 /* exponent strategy data */
516 if (ac3_exponent_strategy) {
517 /* AC-3-style exponent strategy syntax */
518 for (blk = 0; blk < s->num_blocks; blk++) {
519 for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
520 s->exp_strategy[blk][ch] = get_bits(gbc, 2);
524 /* LUT-based exponent strategy syntax */
525 for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
526 int frmchexpstr = get_bits(gbc, 5);
527 for (blk = 0; blk < 6; blk++) {
528 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
532 /* LFE exponent strategy */
534 for (blk = 0; blk < s->num_blocks; blk++) {
535 s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
538 /* original exponent strategies if this stream was converted from AC-3 */
539 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
540 (s->num_blocks == 6 || get_bits1(gbc))) {
541 skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
544 /* determine which channels use AHT */
545 if (parse_aht_info) {
546 /* For AHT to be used, all non-zero blocks must reuse exponents from
547 the first block. Furthermore, for AHT to be used in the coupling
548 channel, all blocks must use coupling and use the same coupling
550 s->channel_uses_aht[CPL_CH]=0;
551 for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
553 for (blk = 1; blk < 6; blk++) {
554 if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
555 (!ch && s->cpl_strategy_exists[blk])) {
560 s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
563 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
566 /* per-frame SNR offset */
567 if (!s->snr_offset_strategy) {
568 int csnroffst = (get_bits(gbc, 6) - 15) << 4;
569 int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
570 for (ch = 0; ch <= s->channels; ch++)
571 s->snr_offset[ch] = snroffst;
574 /* transient pre-noise processing data */
575 if (parse_transient_proc_info) {
576 for (ch = 1; ch <= s->fbw_channels; ch++) {
577 if (get_bits1(gbc)) { // channel in transient processing
578 skip_bits(gbc, 10); // skip transient processing location
579 skip_bits(gbc, 8); // skip transient processing length
584 /* spectral extension attenuation data */
585 for (ch = 1; ch <= s->fbw_channels; ch++) {
586 if (parse_spx_atten_data && get_bits1(gbc)) {
587 s->spx_atten_code[ch] = get_bits(gbc, 5);
589 s->spx_atten_code[ch] = -1;
593 /* block start information */
594 if (s->num_blocks > 1 && get_bits1(gbc)) {
595 /* reference: Section E2.3.2.27
596 nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
597 The spec does not say what this data is or what it's used for.
598 It is likely the offset of each block within the frame. */
599 int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
600 skip_bits_long(gbc, block_start_bits);
601 avpriv_request_sample(s->avctx, "Block start info");
604 /* syntax state initialization */
605 for (ch = 1; ch <= s->fbw_channels; ch++) {
606 s->first_spx_coords[ch] = 1;
607 s->first_cpl_coords[ch] = 1;
609 s->first_cpl_leak = 1;