FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
eac3dec.c
Go to the documentation of this file.
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  * Enhanced Coupling
27  * No known samples exist. If any ever surface, this feature should not be
28  * too difficult to implement.
29  *
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.
33  *
34  * Dependent Streams
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
38  * Blu-ray.
39  *
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.
44  */
45 
46 
47 #include "avcodec.h"
48 #include "internal.h"
49 #include "aac_ac3_parser.h"
50 #include "ac3.h"
51 #include "ac3_parser.h"
52 #include "ac3dec.h"
53 #include "ac3dec_data.h"
54 #include "eac3_data.h"
55 
56 /** gain adaptive quantization mode */
57 typedef enum {
62 } EAC3GaqMode;
63 
64 #define EAC3_SR_CODE_REDUCED 3
65 
67 {
68  int bin, bnd, ch, i;
69  uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];
70  float rms_energy[SPX_MAX_BANDS];
71 
72  /* Set copy index mapping table. Set wrap flags to apply a notch filter at
73  wrap points later on. */
74  bin = s->spx_dst_start_freq;
75  num_copy_sections = 0;
76  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
77  int copysize;
78  int bandsize = s->spx_band_sizes[bnd];
79  if (bin + bandsize > s->spx_src_start_freq) {
80  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
81  bin = s->spx_dst_start_freq;
82  wrapflag[bnd] = 1;
83  }
84  for (i = 0; i < bandsize; i += copysize) {
85  if (bin == s->spx_src_start_freq) {
86  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
87  bin = s->spx_dst_start_freq;
88  }
89  copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);
90  bin += copysize;
91  }
92  }
93  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
94 
95  for (ch = 1; ch <= s->fbw_channels; ch++) {
96  if (!s->channel_uses_spx[ch])
97  continue;
98 
99  /* Copy coeffs from normal bands to extension bands */
100  bin = s->spx_src_start_freq;
101  for (i = 0; i < num_copy_sections; i++) {
102  memcpy(&s->transform_coeffs[ch][bin],
104  copy_sizes[i]*sizeof(float));
105  bin += copy_sizes[i];
106  }
107 
108  /* Calculate RMS energy for each SPX band. */
109  bin = s->spx_src_start_freq;
110  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
111  int bandsize = s->spx_band_sizes[bnd];
112  float accum = 0.0f;
113  for (i = 0; i < bandsize; i++) {
114  float coeff = s->transform_coeffs[ch][bin++];
115  accum += coeff * coeff;
116  }
117  rms_energy[bnd] = sqrtf(accum / bandsize);
118  }
119 
120  /* Apply a notch filter at transitions between normal and extension
121  bands and at all wrap points. */
122  if (s->spx_atten_code[ch] >= 0) {
123  const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];
124  bin = s->spx_src_start_freq - 2;
125  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
126  if (wrapflag[bnd]) {
127  float *coeffs = &s->transform_coeffs[ch][bin];
128  coeffs[0] *= atten_tab[0];
129  coeffs[1] *= atten_tab[1];
130  coeffs[2] *= atten_tab[2];
131  coeffs[3] *= atten_tab[1];
132  coeffs[4] *= atten_tab[0];
133  }
134  bin += s->spx_band_sizes[bnd];
135  }
136  }
137 
138  /* Apply noise-blended coefficient scaling based on previously
139  calculated RMS energy, blending factors, and SPX coordinates for
140  each band. */
141  bin = s->spx_src_start_freq;
142  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
143  float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN);
144  float sscale = s->spx_signal_blend[ch][bnd];
145  for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
146  float noise = nscale * (int32_t)av_lfg_get(&s->dith_state);
147  s->transform_coeffs[ch][bin] *= sscale;
148  s->transform_coeffs[ch][bin++] += noise;
149  }
150  }
151  }
152 }
153 
154 
155 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
156 #define COEFF_0 10273905LL
157 
158 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */
159 #define COEFF_1 11863283LL
160 
161 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */
162 #define COEFF_2 3070444LL
163 
164 /**
165  * Calculate 6-point IDCT of the pre-mantissas.
166  * All calculations are 24-bit fixed-point.
167  */
168 static void idct6(int pre_mant[6])
169 {
170  int tmp;
171  int even0, even1, even2, odd0, odd1, odd2;
172 
173  odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
174 
175  even2 = ( pre_mant[2] * COEFF_0) >> 23;
176  tmp = ( pre_mant[4] * COEFF_1) >> 23;
177  odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
178 
179  even0 = pre_mant[0] + (tmp >> 1);
180  even1 = pre_mant[0] - tmp;
181 
182  tmp = even0;
183  even0 = tmp + even2;
184  even2 = tmp - even2;
185 
186  tmp = odd0;
187  odd0 = tmp + pre_mant[1] + pre_mant[3];
188  odd2 = tmp + pre_mant[5] - pre_mant[3];
189 
190  pre_mant[0] = even0 + odd0;
191  pre_mant[1] = even1 + odd1;
192  pre_mant[2] = even2 + odd2;
193  pre_mant[3] = even2 - odd2;
194  pre_mant[4] = even1 - odd1;
195  pre_mant[5] = even0 - odd0;
196 }
197 
199 {
200  int bin, blk, gs;
201  int end_bap, gaq_mode;
202  GetBitContext *gbc = &s->gbc;
203  int gaq_gain[AC3_MAX_COEFS];
204 
205  gaq_mode = get_bits(gbc, 2);
206  end_bap = (gaq_mode < 2) ? 12 : 17;
207 
208  /* if GAQ gain is used, decode gain codes for bins with hebap between
209  8 and end_bap */
210  gs = 0;
211  if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
212  /* read 1-bit GAQ gain codes */
213  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
214  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
215  gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
216  }
217  } else if (gaq_mode == EAC3_GAQ_124) {
218  /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
219  int gc = 2;
220  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
221  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
222  if (gc++ == 2) {
223  int group_code = get_bits(gbc, 5);
224  if (group_code > 26) {
225  av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
226  group_code = 26;
227  }
228  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
229  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
230  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
231  gc = 0;
232  }
233  }
234  }
235  }
236 
237  gs=0;
238  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
239  int hebap = s->bap[ch][bin];
240  int bits = ff_eac3_bits_vs_hebap[hebap];
241  if (!hebap) {
242  /* zero-mantissa dithering */
243  for (blk = 0; blk < 6; blk++) {
244  s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
245  }
246  } else if (hebap < 8) {
247  /* Vector Quantization */
248  int v = get_bits(gbc, bits);
249  for (blk = 0; blk < 6; blk++) {
250  s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
251  }
252  } else {
253  /* Gain Adaptive Quantization */
254  int gbits, log_gain;
255  if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
256  log_gain = gaq_gain[gs++];
257  } else {
258  log_gain = 0;
259  }
260  gbits = bits - log_gain;
261 
262  for (blk = 0; blk < 6; blk++) {
263  int mant = get_sbits(gbc, gbits);
264  if (log_gain && mant == -(1 << (gbits-1))) {
265  /* large mantissa */
266  int b;
267  int mbits = bits - (2 - log_gain);
268  mant = get_sbits(gbc, mbits);
269  mant <<= (23 - (mbits - 1));
270  /* remap mantissa value to correct for asymmetric quantization */
271  if (mant >= 0)
272  b = 1 << (23 - log_gain);
273  else
274  b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8;
275  mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
276  } else {
277  /* small mantissa, no GAQ, or Gk=1 */
278  mant <<= 24 - bits;
279  if (!log_gain) {
280  /* remap mantissa value for no GAQ or Gk=1 */
281  mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
282  }
283  }
284  s->pre_mantissa[ch][bin][blk] = mant;
285  }
286  }
287  idct6(s->pre_mantissa[ch][bin]);
288  }
289 }
290 
292 {
293  int i, blk, ch;
294  int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
295  int parse_transient_proc_info;
296  int num_cpl_blocks;
297  GetBitContext *gbc = &s->gbc;
298 
299  /* An E-AC-3 stream can have multiple independent streams which the
300  application can select from. each independent stream can also contain
301  dependent streams which are used to add or replace channels. */
303  avpriv_request_sample(s->avctx, "Dependent substream decoding");
305  } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
306  av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
308  }
309 
310  /* The substream id indicates which substream this frame belongs to. each
311  independent stream has its own substream id, and the dependent streams
312  associated to an independent stream have matching substream id's. */
313  if (s->substreamid) {
314  /* only decode substream with id=0. skip any additional substreams. */
315  avpriv_request_sample(s->avctx, "Additional substreams");
317  }
318 
320  /* The E-AC-3 specification does not tell how to handle reduced sample
321  rates in bit allocation. The best assumption would be that it is
322  handled like AC-3 DolbyNet, but we cannot be sure until we have a
323  sample which utilizes this feature. */
324  avpriv_request_sample(s->avctx, "Reduced sampling rate");
325  return AVERROR_PATCHWELCOME;
326  }
327  skip_bits(gbc, 5); // skip bitstream id
328 
329  /* volume control params */
330  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
331  skip_bits(gbc, 5); // skip dialog normalization
332  if (get_bits1(gbc)) {
333  skip_bits(gbc, 8); // skip compression gain word
334  }
335  }
336 
337  /* dependent stream channel map */
339  if (get_bits1(gbc)) {
340  skip_bits(gbc, 16); // skip custom channel map
341  }
342  }
343 
344  /* mixing metadata */
345  if (get_bits1(gbc)) {
346  /* center and surround mix levels */
347  if (s->channel_mode > AC3_CHMODE_STEREO) {
348  s->preferred_downmix = get_bits(gbc, 2);
349  if (s->channel_mode & 1) {
350  /* if three front channels exist */
351  s->center_mix_level_ltrt = get_bits(gbc, 3);
352  s->center_mix_level = get_bits(gbc, 3);
353  }
354  if (s->channel_mode & 4) {
355  /* if a surround channel exists */
356  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
357  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
358  }
359  }
360 
361  /* lfe mix level */
362  if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) {
363  s->lfe_mix_level = get_bits(gbc, 5);
364  }
365 
366  /* info for mixing with other streams and substreams */
368  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
369  // TODO: apply program scale factor
370  if (get_bits1(gbc)) {
371  skip_bits(gbc, 6); // skip program scale factor
372  }
373  }
374  if (get_bits1(gbc)) {
375  skip_bits(gbc, 6); // skip external program scale factor
376  }
377  /* skip mixing parameter data */
378  switch(get_bits(gbc, 2)) {
379  case 1: skip_bits(gbc, 5); break;
380  case 2: skip_bits(gbc, 12); break;
381  case 3: {
382  int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
383  skip_bits_long(gbc, mix_data_size);
384  break;
385  }
386  }
387  /* skip pan information for mono or dual mono source */
388  if (s->channel_mode < AC3_CHMODE_STEREO) {
389  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
390  if (get_bits1(gbc)) {
391  /* note: this is not in the ATSC A/52B specification
392  reference: ETSI TS 102 366 V1.1.1
393  section: E.1.3.1.25 */
394  skip_bits(gbc, 8); // skip pan mean direction index
395  skip_bits(gbc, 6); // skip reserved paninfo bits
396  }
397  }
398  }
399  /* skip mixing configuration information */
400  if (get_bits1(gbc)) {
401  for (blk = 0; blk < s->num_blocks; blk++) {
402  if (s->num_blocks == 1 || get_bits1(gbc)) {
403  skip_bits(gbc, 5);
404  }
405  }
406  }
407  }
408  }
409 
410  /* informational metadata */
411  if (get_bits1(gbc)) {
412  s->bitstream_mode = get_bits(gbc, 3);
413  skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
414  if (s->channel_mode == AC3_CHMODE_STEREO) {
415  s->dolby_surround_mode = get_bits(gbc, 2);
416  s->dolby_headphone_mode = get_bits(gbc, 2);
417  }
418  if (s->channel_mode >= AC3_CHMODE_2F2R) {
419  s->dolby_surround_ex_mode = get_bits(gbc, 2);
420  }
421  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
422  if (get_bits1(gbc)) {
423  skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
424  }
425  }
427  skip_bits1(gbc); // skip source sample rate code
428  }
429  }
430 
431  /* converter synchronization flag
432  If frames are less than six blocks, this bit should be turned on
433  once every 6 blocks to indicate the start of a frame set.
434  reference: RFC 4598, Section 2.1.3 Frame Sets */
435  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
436  skip_bits1(gbc); // skip converter synchronization flag
437  }
438 
439  /* original frame size code if this stream was converted from AC-3 */
441  (s->num_blocks == 6 || get_bits1(gbc))) {
442  skip_bits(gbc, 6); // skip frame size code
443  }
444 
445  /* additional bitstream info */
446  if (get_bits1(gbc)) {
447  int addbsil = get_bits(gbc, 6);
448  for (i = 0; i < addbsil + 1; i++) {
449  skip_bits(gbc, 8); // skip additional bit stream info
450  }
451  }
452 
453  /* audio frame syntax flags, strategy data, and per-frame data */
454 
455  if (s->num_blocks == 6) {
456  ac3_exponent_strategy = get_bits1(gbc);
457  parse_aht_info = get_bits1(gbc);
458  } else {
459  /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
460  do not use AHT */
461  ac3_exponent_strategy = 1;
462  parse_aht_info = 0;
463  }
464 
465  s->snr_offset_strategy = get_bits(gbc, 2);
466  parse_transient_proc_info = get_bits1(gbc);
467 
468  s->block_switch_syntax = get_bits1(gbc);
469  if (!s->block_switch_syntax)
470  memset(s->block_switch, 0, sizeof(s->block_switch));
471 
472  s->dither_flag_syntax = get_bits1(gbc);
473  if (!s->dither_flag_syntax) {
474  for (ch = 1; ch <= s->fbw_channels; ch++)
475  s->dither_flag[ch] = 1;
476  }
477  s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
478 
480  if (!s->bit_allocation_syntax) {
481  /* set default bit allocation parameters */
487  }
488 
489  s->fast_gain_syntax = get_bits1(gbc);
490  s->dba_syntax = get_bits1(gbc);
491  s->skip_syntax = get_bits1(gbc);
492  parse_spx_atten_data = get_bits1(gbc);
493 
494  /* coupling strategy occurrence and coupling use per block */
495  num_cpl_blocks = 0;
496  if (s->channel_mode > 1) {
497  for (blk = 0; blk < s->num_blocks; blk++) {
498  s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
499  if (s->cpl_strategy_exists[blk]) {
500  s->cpl_in_use[blk] = get_bits1(gbc);
501  } else {
502  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
503  }
504  num_cpl_blocks += s->cpl_in_use[blk];
505  }
506  } else {
507  memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
508  }
509 
510  /* exponent strategy data */
511  if (ac3_exponent_strategy) {
512  /* AC-3-style exponent strategy syntax */
513  for (blk = 0; blk < s->num_blocks; blk++) {
514  for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
515  s->exp_strategy[blk][ch] = get_bits(gbc, 2);
516  }
517  }
518  } else {
519  /* LUT-based exponent strategy syntax */
520  for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
521  int frmchexpstr = get_bits(gbc, 5);
522  for (blk = 0; blk < 6; blk++) {
523  s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
524  }
525  }
526  }
527  /* LFE exponent strategy */
528  if (s->lfe_on) {
529  for (blk = 0; blk < s->num_blocks; blk++) {
530  s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
531  }
532  }
533  /* original exponent strategies if this stream was converted from AC-3 */
535  (s->num_blocks == 6 || get_bits1(gbc))) {
536  skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
537  }
538 
539  /* determine which channels use AHT */
540  if (parse_aht_info) {
541  /* For AHT to be used, all non-zero blocks must reuse exponents from
542  the first block. Furthermore, for AHT to be used in the coupling
543  channel, all blocks must use coupling and use the same coupling
544  strategy. */
545  s->channel_uses_aht[CPL_CH]=0;
546  for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
547  int use_aht = 1;
548  for (blk = 1; blk < 6; blk++) {
549  if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
550  (!ch && s->cpl_strategy_exists[blk])) {
551  use_aht = 0;
552  break;
553  }
554  }
555  s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
556  }
557  } else {
558  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
559  }
560 
561  /* per-frame SNR offset */
562  if (!s->snr_offset_strategy) {
563  int csnroffst = (get_bits(gbc, 6) - 15) << 4;
564  int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
565  for (ch = 0; ch <= s->channels; ch++)
566  s->snr_offset[ch] = snroffst;
567  }
568 
569  /* transient pre-noise processing data */
570  if (parse_transient_proc_info) {
571  for (ch = 1; ch <= s->fbw_channels; ch++) {
572  if (get_bits1(gbc)) { // channel in transient processing
573  skip_bits(gbc, 10); // skip transient processing location
574  skip_bits(gbc, 8); // skip transient processing length
575  }
576  }
577  }
578 
579  /* spectral extension attenuation data */
580  for (ch = 1; ch <= s->fbw_channels; ch++) {
581  if (parse_spx_atten_data && get_bits1(gbc)) {
582  s->spx_atten_code[ch] = get_bits(gbc, 5);
583  } else {
584  s->spx_atten_code[ch] = -1;
585  }
586  }
587 
588  /* block start information */
589  if (s->num_blocks > 1 && get_bits1(gbc)) {
590  /* reference: Section E2.3.2.27
591  nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
592  The spec does not say what this data is or what it's used for.
593  It is likely the offset of each block within the frame. */
594  int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
595  skip_bits_long(gbc, block_start_bits);
596  avpriv_request_sample(s->avctx, "Block start info");
597  }
598 
599  /* syntax state initialization */
600  for (ch = 1; ch <= s->fbw_channels; ch++) {
601  s->first_spx_coords[ch] = 1;
602  s->first_cpl_coords[ch] = 1;
603  }
604  s->first_cpl_leak = 1;
605 
606  return 0;
607 }