FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ac3dec.c
Go to the documentation of this file.
1 /*
2  * AC-3 Audio Decoder
3  * This code was developed as part of Google Summer of Code 2006.
4  * E-AC-3 support was added as part of Google Summer of Code 2007.
5  *
6  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
7  * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8  * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 #include <stdio.h>
28 #include <stddef.h>
29 #include <math.h>
30 #include <string.h>
31 
32 #include "libavutil/channel_layout.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/downmix_info.h"
35 #include "libavutil/opt.h"
36 #include "internal.h"
37 #include "aac_ac3_parser.h"
38 #include "ac3_parser.h"
39 #include "ac3dec.h"
40 #include "ac3dec_data.h"
41 #include "kbdwin.h"
42 
43 /**
44  * table for ungrouping 3 values in 7 bits.
45  * used for exponents and bap=2 mantissas
46  */
47 static uint8_t ungroup_3_in_7_bits_tab[128][3];
48 
49 /** tables for ungrouping mantissas */
50 static int b1_mantissas[32][3];
51 static int b2_mantissas[128][3];
52 static int b3_mantissas[8];
53 static int b4_mantissas[128][2];
54 static int b5_mantissas[16];
55 
56 /**
57  * Quantization table: levels for symmetric. bits for asymmetric.
58  * reference: Table 7.18 Mapping of bap to Quantizer
59  */
60 static const uint8_t quantization_tab[16] = {
61  0, 3, 5, 7, 11, 15,
62  5, 6, 7, 8, 9, 10, 11, 12, 14, 16
63 };
64 
65 /** dynamic range table. converts codes to scale factors. */
66 static float dynamic_range_tab[256];
67 
68 /** Adjustments in dB gain */
69 static const float gain_levels[9] = {
70  LEVEL_PLUS_3DB,
71  LEVEL_PLUS_1POINT5DB,
72  LEVEL_ONE,
73  LEVEL_MINUS_1POINT5DB,
74  LEVEL_MINUS_3DB,
75  LEVEL_MINUS_4POINT5DB,
76  LEVEL_MINUS_6DB,
77  LEVEL_ZERO,
78  LEVEL_MINUS_9DB
79 };
80 
81 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
82 static const float gain_levels_lfe[32] = {
83  3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
84  1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
85  0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
86  0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
87  0.125892, 0.112201, 0.100000, 0.089125
88 };
89 
90 /**
91  * Table for default stereo downmixing coefficients
92  * reference: Section 7.8.2 Downmixing Into Two Channels
93  */
94 static const uint8_t ac3_default_coeffs[8][5][2] = {
95  { { 2, 7 }, { 7, 2 }, },
96  { { 4, 4 }, },
97  { { 2, 7 }, { 7, 2 }, },
98  { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
99  { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
100  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
101  { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
102  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
103 };
104 
105 /**
106  * Symmetrical Dequantization
107  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
108  * Tables 7.19 to 7.23
109  */
110 static inline int
111 symmetric_dequant(int code, int levels)
112 {
113  return ((code - (levels >> 1)) << 24) / levels;
114 }
115 
116 /*
117  * Initialize tables at runtime.
118  */
119 static av_cold void ac3_tables_init(void)
120 {
121  int i;
122 
123  /* generate table for ungrouping 3 values in 7 bits
124  reference: Section 7.1.3 Exponent Decoding */
125  for (i = 0; i < 128; i++) {
126  ungroup_3_in_7_bits_tab[i][0] = i / 25;
127  ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
128  ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
129  }
130 
131  /* generate grouped mantissa tables
132  reference: Section 7.3.5 Ungrouping of Mantissas */
133  for (i = 0; i < 32; i++) {
134  /* bap=1 mantissas */
135  b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
136  b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
137  b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
138  }
139  for (i = 0; i < 128; i++) {
140  /* bap=2 mantissas */
141  b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
142  b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
143  b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
144 
145  /* bap=4 mantissas */
146  b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
147  b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
148  }
149  /* generate ungrouped mantissa tables
150  reference: Tables 7.21 and 7.23 */
151  for (i = 0; i < 7; i++) {
152  /* bap=3 mantissas */
153  b3_mantissas[i] = symmetric_dequant(i, 7);
154  }
155  for (i = 0; i < 15; i++) {
156  /* bap=5 mantissas */
157  b5_mantissas[i] = symmetric_dequant(i, 15);
158  }
159 
160  /* generate dynamic range table
161  reference: Section 7.7.1 Dynamic Range Control */
162  for (i = 0; i < 256; i++) {
163  int v = (i >> 5) - ((i >> 7) << 3) - 5;
164  dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
165  }
166 }
167 
168 /**
169  * AVCodec initialization
170  */
171 static av_cold int ac3_decode_init(AVCodecContext *avctx)
172 {
173  AC3DecodeContext *s = avctx->priv_data;
174  int i;
175 
176  s->avctx = avctx;
177 
178  ff_ac3_common_init();
179  ac3_tables_init();
180  ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
181  ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
182  ff_kbd_window_init(s->window, 5.0, 256);
183  ff_dsputil_init(&s->dsp, avctx);
184  avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
185  ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
186  ff_fmt_convert_init(&s->fmt_conv, avctx);
187  av_lfg_init(&s->dith_state, 0);
188 
189  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
190 
191  /* allow downmixing to stereo or mono */
192 #if FF_API_REQUEST_CHANNELS
193 FF_DISABLE_DEPRECATION_WARNINGS
194  if (avctx->request_channels == 1)
195  avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
196  else if (avctx->request_channels == 2)
197  avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
198 FF_ENABLE_DEPRECATION_WARNINGS
199 #endif
200  if (avctx->channels > 1 &&
201  avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
202  avctx->channels = 1;
203  else if (avctx->channels > 2 &&
204  avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
205  avctx->channels = 2;
206  s->downmixed = 1;
207 
208  for (i = 0; i < AC3_MAX_CHANNELS; i++) {
209  s->xcfptr[i] = s->transform_coeffs[i];
210  s->dlyptr[i] = s->delay[i];
211  }
212 
213  return 0;
214 }
215 
216 /**
217  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
218  * GetBitContext within AC3DecodeContext must point to
219  * the start of the synchronized AC-3 bitstream.
220  */
221 static int ac3_parse_header(AC3DecodeContext *s)
222 {
223  GetBitContext *gbc = &s->gbc;
224  int i;
225 
226  /* read the rest of the bsi. read twice for dual mono mode. */
227  i = !s->channel_mode;
228  do {
229  skip_bits(gbc, 5); // skip dialog normalization
230  if (get_bits1(gbc))
231  skip_bits(gbc, 8); //skip compression
232  if (get_bits1(gbc))
233  skip_bits(gbc, 8); //skip language code
234  if (get_bits1(gbc))
235  skip_bits(gbc, 7); //skip audio production information
236  } while (i--);
237 
238  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
239 
240  /* skip the timecodes or parse the Alternate Bit Stream Syntax */
241  if (s->bitstream_id != 6) {
242  if (get_bits1(gbc))
243  skip_bits(gbc, 14); //skip timecode1
244  if (get_bits1(gbc))
245  skip_bits(gbc, 14); //skip timecode2
246  } else {
247  if (get_bits1(gbc)) {
248  s->preferred_downmix = get_bits(gbc, 2);
249  s->center_mix_level_ltrt = get_bits(gbc, 3);
250  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
251  s->center_mix_level = get_bits(gbc, 3);
252  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
253  }
254  if (get_bits1(gbc)) {
255  s->dolby_surround_ex_mode = get_bits(gbc, 2);
256  s->dolby_headphone_mode = get_bits(gbc, 2);
257  skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
258  }
259  }
260 
261  /* skip additional bitstream info */
262  if (get_bits1(gbc)) {
263  i = get_bits(gbc, 6);
264  do {
265  skip_bits(gbc, 8);
266  } while (i--);
267  }
268 
269  return 0;
270 }
271 
272 /**
273  * Common function to parse AC-3 or E-AC-3 frame header
274  */
275 static int parse_frame_header(AC3DecodeContext *s)
276 {
277  AC3HeaderInfo hdr, *phdr=&hdr;
278  int err;
279 
280  err = avpriv_ac3_parse_header2(&s->gbc, &phdr);
281  if (err)
282  return err;
283 
284  /* get decoding parameters from header info */
285  s->bit_alloc_params.sr_code = hdr.sr_code;
286  s->bitstream_id = hdr.bitstream_id;
287  s->bitstream_mode = hdr.bitstream_mode;
288  s->channel_mode = hdr.channel_mode;
289  s->lfe_on = hdr.lfe_on;
290  s->bit_alloc_params.sr_shift = hdr.sr_shift;
291  s->sample_rate = hdr.sample_rate;
292  s->bit_rate = hdr.bit_rate;
293  s->channels = hdr.channels;
294  s->fbw_channels = s->channels - s->lfe_on;
295  s->lfe_ch = s->fbw_channels + 1;
296  s->frame_size = hdr.frame_size;
297  s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
298  s->center_mix_level = hdr.center_mix_level;
299  s->center_mix_level_ltrt = 4; // -3.0dB
300  s->surround_mix_level = hdr.surround_mix_level;
301  s->surround_mix_level_ltrt = 4; // -3.0dB
302  s->lfe_mix_level_exists = 0;
303  s->num_blocks = hdr.num_blocks;
304  s->frame_type = hdr.frame_type;
305  s->substreamid = hdr.substreamid;
306  s->dolby_surround_mode = hdr.dolby_surround_mode;
307  s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
308  s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
309 
310  if (s->lfe_on) {
311  s->start_freq[s->lfe_ch] = 0;
312  s->end_freq[s->lfe_ch] = 7;
313  s->num_exp_groups[s->lfe_ch] = 2;
314  s->channel_in_cpl[s->lfe_ch] = 0;
315  }
316 
317  if (s->bitstream_id <= 10) {
318  s->eac3 = 0;
319  s->snr_offset_strategy = 2;
320  s->block_switch_syntax = 1;
321  s->dither_flag_syntax = 1;
322  s->bit_allocation_syntax = 1;
323  s->fast_gain_syntax = 0;
324  s->first_cpl_leak = 0;
325  s->dba_syntax = 1;
326  s->skip_syntax = 1;
327  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
328  return ac3_parse_header(s);
329  } else if (CONFIG_EAC3_DECODER) {
330  s->eac3 = 1;
331  return ff_eac3_parse_header(s);
332  } else {
333  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
334  return AVERROR(ENOSYS);
335  }
336 }
337 
338 /**
339  * Set stereo downmixing coefficients based on frame header info.
340  * reference: Section 7.8.2 Downmixing Into Two Channels
341  */
342 static void set_downmix_coeffs(AC3DecodeContext *s)
343 {
344  int i;
345  float cmix = gain_levels[s-> center_mix_level];
346  float smix = gain_levels[s->surround_mix_level];
347  float norm0, norm1;
348 
349  for (i = 0; i < s->fbw_channels; i++) {
350  s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
351  s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
352  }
353  if (s->channel_mode > 1 && s->channel_mode & 1) {
354  s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
355  }
356  if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
357  int nf = s->channel_mode - 2;
358  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
359  }
360  if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
361  int nf = s->channel_mode - 4;
362  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
363  }
364 
365  /* renormalize */
366  norm0 = norm1 = 0.0;
367  for (i = 0; i < s->fbw_channels; i++) {
368  norm0 += s->downmix_coeffs[i][0];
369  norm1 += s->downmix_coeffs[i][1];
370  }
371  norm0 = 1.0f / norm0;
372  norm1 = 1.0f / norm1;
373  for (i = 0; i < s->fbw_channels; i++) {
374  s->downmix_coeffs[i][0] *= norm0;
375  s->downmix_coeffs[i][1] *= norm1;
376  }
377 
378  if (s->output_mode == AC3_CHMODE_MONO) {
379  for (i = 0; i < s->fbw_channels; i++)
380  s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
381  s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
382  }
383 }
384 
385 /**
386  * Decode the grouped exponents according to exponent strategy.
387  * reference: Section 7.1.3 Exponent Decoding
388  */
389 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
390  uint8_t absexp, int8_t *dexps)
391 {
392  int i, j, grp, group_size;
393  int dexp[256];
394  int expacc, prevexp;
395 
396  /* unpack groups */
397  group_size = exp_strategy + (exp_strategy == EXP_D45);
398  for (grp = 0, i = 0; grp < ngrps; grp++) {
399  expacc = get_bits(gbc, 7);
400  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
401  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
402  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
403  }
404 
405  /* convert to absolute exps and expand groups */
406  prevexp = absexp;
407  for (i = 0, j = 0; i < ngrps * 3; i++) {
408  prevexp += dexp[i] - 2;
409  if (prevexp > 24U)
410  return -1;
411  switch (group_size) {
412  case 4: dexps[j++] = prevexp;
413  dexps[j++] = prevexp;
414  case 2: dexps[j++] = prevexp;
415  case 1: dexps[j++] = prevexp;
416  }
417  }
418  return 0;
419 }
420 
421 /**
422  * Generate transform coefficients for each coupled channel in the coupling
423  * range using the coupling coefficients and coupling coordinates.
424  * reference: Section 7.4.3 Coupling Coordinate Format
425  */
426 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
427 {
428  int bin, band, ch;
429 
430  bin = s->start_freq[CPL_CH];
431  for (band = 0; band < s->num_cpl_bands; band++) {
432  int band_start = bin;
433  int band_end = bin + s->cpl_band_sizes[band];
434  for (ch = 1; ch <= s->fbw_channels; ch++) {
435  if (s->channel_in_cpl[ch]) {
436  int cpl_coord = s->cpl_coords[ch][band] << 5;
437  for (bin = band_start; bin < band_end; bin++) {
438  s->fixed_coeffs[ch][bin] =
439  MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
440  }
441  if (ch == 2 && s->phase_flags[band]) {
442  for (bin = band_start; bin < band_end; bin++)
443  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
444  }
445  }
446  }
447  bin = band_end;
448  }
449 }
450 
451 /**
452  * Grouped mantissas for 3-level 5-level and 11-level quantization
453  */
454 typedef struct {
455  int b1_mant[2];
456  int b2_mant[2];
457  int b4_mant;
458  int b1;
459  int b2;
460  int b4;
461 } mant_groups;
462 
463 /**
464  * Decode the transform coefficients for a particular channel
465  * reference: Section 7.3 Quantization and Decoding of Mantissas
466  */
467 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
468 {
469  int start_freq = s->start_freq[ch_index];
470  int end_freq = s->end_freq[ch_index];
471  uint8_t *baps = s->bap[ch_index];
472  int8_t *exps = s->dexps[ch_index];
473  int32_t *coeffs = s->fixed_coeffs[ch_index];
474  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
475  GetBitContext *gbc = &s->gbc;
476  int freq;
477 
478  for (freq = start_freq; freq < end_freq; freq++) {
479  int bap = baps[freq];
480  int mantissa;
481  switch (bap) {
482  case 0:
483  /* random noise with approximate range of -0.707 to 0.707 */
484  if (dither)
485  mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
486  else
487  mantissa = 0;
488  break;
489  case 1:
490  if (m->b1) {
491  m->b1--;
492  mantissa = m->b1_mant[m->b1];
493  } else {
494  int bits = get_bits(gbc, 5);
495  mantissa = b1_mantissas[bits][0];
496  m->b1_mant[1] = b1_mantissas[bits][1];
497  m->b1_mant[0] = b1_mantissas[bits][2];
498  m->b1 = 2;
499  }
500  break;
501  case 2:
502  if (m->b2) {
503  m->b2--;
504  mantissa = m->b2_mant[m->b2];
505  } else {
506  int bits = get_bits(gbc, 7);
507  mantissa = b2_mantissas[bits][0];
508  m->b2_mant[1] = b2_mantissas[bits][1];
509  m->b2_mant[0] = b2_mantissas[bits][2];
510  m->b2 = 2;
511  }
512  break;
513  case 3:
514  mantissa = b3_mantissas[get_bits(gbc, 3)];
515  break;
516  case 4:
517  if (m->b4) {
518  m->b4 = 0;
519  mantissa = m->b4_mant;
520  } else {
521  int bits = get_bits(gbc, 7);
522  mantissa = b4_mantissas[bits][0];
523  m->b4_mant = b4_mantissas[bits][1];
524  m->b4 = 1;
525  }
526  break;
527  case 5:
528  mantissa = b5_mantissas[get_bits(gbc, 4)];
529  break;
530  default: /* 6 to 15 */
531  /* Shift mantissa and sign-extend it. */
532  if (bap > 15) {
533  av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
534  bap = 15;
535  }
536  mantissa = get_sbits(gbc, quantization_tab[bap]);
537  mantissa <<= 24 - quantization_tab[bap];
538  break;
539  }
540  coeffs[freq] = mantissa >> exps[freq];
541  }
542 }
543 
544 /**
545  * Remove random dithering from coupling range coefficients with zero-bit
546  * mantissas for coupled channels which do not use dithering.
547  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
548  */
549 static void remove_dithering(AC3DecodeContext *s) {
550  int ch, i;
551 
552  for (ch = 1; ch <= s->fbw_channels; ch++) {
553  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
554  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
555  if (!s->bap[CPL_CH][i])
556  s->fixed_coeffs[ch][i] = 0;
557  }
558  }
559  }
560 }
561 
562 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
563  mant_groups *m)
564 {
565  if (!s->channel_uses_aht[ch]) {
566  ac3_decode_transform_coeffs_ch(s, ch, m);
567  } else {
568  /* if AHT is used, mantissas for all blocks are encoded in the first
569  block of the frame. */
570  int bin;
571  if (!blk && CONFIG_EAC3_DECODER)
572  ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
573  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
574  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
575  }
576  }
577 }
578 
579 /**
580  * Decode the transform coefficients.
581  */
582 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
583 {
584  int ch, end;
585  int got_cplchan = 0;
586  mant_groups m;
587 
588  m.b1 = m.b2 = m.b4 = 0;
589 
590  for (ch = 1; ch <= s->channels; ch++) {
591  /* transform coefficients for full-bandwidth channel */
592  decode_transform_coeffs_ch(s, blk, ch, &m);
593  /* transform coefficients for coupling channel come right after the
594  coefficients for the first coupled channel*/
595  if (s->channel_in_cpl[ch]) {
596  if (!got_cplchan) {
597  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
598  calc_transform_coeffs_cpl(s);
599  got_cplchan = 1;
600  }
601  end = s->end_freq[CPL_CH];
602  } else {
603  end = s->end_freq[ch];
604  }
605  do
606  s->fixed_coeffs[ch][end] = 0;
607  while (++end < 256);
608  }
609 
610  /* zero the dithered coefficients for appropriate channels */
611  remove_dithering(s);
612 }
613 
614 /**
615  * Stereo rematrixing.
616  * reference: Section 7.5.4 Rematrixing : Decoding Technique
617  */
618 static void do_rematrixing(AC3DecodeContext *s)
619 {
620  int bnd, i;
621  int end, bndend;
622 
623  end = FFMIN(s->end_freq[1], s->end_freq[2]);
624 
625  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
626  if (s->rematrixing_flags[bnd]) {
627  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
628  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
629  int tmp0 = s->fixed_coeffs[1][i];
630  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
631  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
632  }
633  }
634  }
635 }
636 
637 /**
638  * Inverse MDCT Transform.
639  * Convert frequency domain coefficients to time-domain audio samples.
640  * reference: Section 7.9.4 Transformation Equations
641  */
642 static inline void do_imdct(AC3DecodeContext *s, int channels)
643 {
644  int ch;
645 
646  for (ch = 1; ch <= channels; ch++) {
647  if (s->block_switch[ch]) {
648  int i;
649  float *x = s->tmp_output + 128;
650  for (i = 0; i < 128; i++)
651  x[i] = s->transform_coeffs[ch][2 * i];
652  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
653  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
654  s->tmp_output, s->window, 128);
655  for (i = 0; i < 128; i++)
656  x[i] = s->transform_coeffs[ch][2 * i + 1];
657  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
658  } else {
659  s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
660  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
661  s->tmp_output, s->window, 128);
662  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
663  }
664  }
665 }
666 
667 /**
668  * Upmix delay samples from stereo to original channel layout.
669  */
670 static void ac3_upmix_delay(AC3DecodeContext *s)
671 {
672  int channel_data_size = sizeof(s->delay[0]);
673  switch (s->channel_mode) {
674  case AC3_CHMODE_DUALMONO:
675  case AC3_CHMODE_STEREO:
676  /* upmix mono to stereo */
677  memcpy(s->delay[1], s->delay[0], channel_data_size);
678  break;
679  case AC3_CHMODE_2F2R:
680  memset(s->delay[3], 0, channel_data_size);
681  case AC3_CHMODE_2F1R:
682  memset(s->delay[2], 0, channel_data_size);
683  break;
684  case AC3_CHMODE_3F2R:
685  memset(s->delay[4], 0, channel_data_size);
686  case AC3_CHMODE_3F1R:
687  memset(s->delay[3], 0, channel_data_size);
688  case AC3_CHMODE_3F:
689  memcpy(s->delay[2], s->delay[1], channel_data_size);
690  memset(s->delay[1], 0, channel_data_size);
691  break;
692  }
693 }
694 
695 /**
696  * Decode band structure for coupling, spectral extension, or enhanced coupling.
697  * The band structure defines how many subbands are in each band. For each
698  * subband in the range, 1 means it is combined with the previous band, and 0
699  * means that it starts a new band.
700  *
701  * @param[in] gbc bit reader context
702  * @param[in] blk block number
703  * @param[in] eac3 flag to indicate E-AC-3
704  * @param[in] ecpl flag to indicate enhanced coupling
705  * @param[in] start_subband subband number for start of range
706  * @param[in] end_subband subband number for end of range
707  * @param[in] default_band_struct default band structure table
708  * @param[out] num_bands number of bands (optionally NULL)
709  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
710  */
711 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
712  int ecpl, int start_subband, int end_subband,
713  const uint8_t *default_band_struct,
714  int *num_bands, uint8_t *band_sizes)
715 {
716  int subbnd, bnd, n_subbands, n_bands=0;
717  uint8_t bnd_sz[22];
718  uint8_t coded_band_struct[22];
719  const uint8_t *band_struct;
720 
721  n_subbands = end_subband - start_subband;
722 
723  /* decode band structure from bitstream or use default */
724  if (!eac3 || get_bits1(gbc)) {
725  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
726  coded_band_struct[subbnd] = get_bits1(gbc);
727  }
728  band_struct = coded_band_struct;
729  } else if (!blk) {
730  band_struct = &default_band_struct[start_subband+1];
731  } else {
732  /* no change in band structure */
733  return;
734  }
735 
736  /* calculate number of bands and band sizes based on band structure.
737  note that the first 4 subbands in enhanced coupling span only 6 bins
738  instead of 12. */
739  if (num_bands || band_sizes ) {
740  n_bands = n_subbands;
741  bnd_sz[0] = ecpl ? 6 : 12;
742  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
743  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
744  if (band_struct[subbnd - 1]) {
745  n_bands--;
746  bnd_sz[bnd] += subbnd_size;
747  } else {
748  bnd_sz[++bnd] = subbnd_size;
749  }
750  }
751  }
752 
753  /* set optional output params */
754  if (num_bands)
755  *num_bands = n_bands;
756  if (band_sizes)
757  memcpy(band_sizes, bnd_sz, n_bands);
758 }
759 
760 /**
761  * Decode a single audio block from the AC-3 bitstream.
762  */
763 static int decode_audio_block(AC3DecodeContext *s, int blk)
764 {
765  int fbw_channels = s->fbw_channels;
766  int channel_mode = s->channel_mode;
767  int i, bnd, seg, ch;
768  int different_transforms;
769  int downmix_output;
770  int cpl_in_use;
771  GetBitContext *gbc = &s->gbc;
772  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
773 
774  /* block switch flags */
775  different_transforms = 0;
776  if (s->block_switch_syntax) {
777  for (ch = 1; ch <= fbw_channels; ch++) {
778  s->block_switch[ch] = get_bits1(gbc);
779  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
780  different_transforms = 1;
781  }
782  }
783 
784  /* dithering flags */
785  if (s->dither_flag_syntax) {
786  for (ch = 1; ch <= fbw_channels; ch++) {
787  s->dither_flag[ch] = get_bits1(gbc);
788  }
789  }
790 
791  /* dynamic range */
792  i = !s->channel_mode;
793  do {
794  if (get_bits1(gbc)) {
795  /* Allow asymmetric application of DRC when drc_scale > 1.
796  Amplification of quiet sounds is enhanced */
797  float range = dynamic_range_tab[get_bits(gbc, 8)];
798  if (range > 1.0 || s->drc_scale <= 1.0)
799  s->dynamic_range[i] = powf(range, s->drc_scale);
800  else
801  s->dynamic_range[i] = range;
802  } else if (blk == 0) {
803  s->dynamic_range[i] = 1.0f;
804  }
805  } while (i--);
806 
807  /* spectral extension strategy */
808  if (s->eac3 && (!blk || get_bits1(gbc))) {
809  s->spx_in_use = get_bits1(gbc);
810  if (s->spx_in_use) {
811  int dst_start_freq, dst_end_freq, src_start_freq,
812  start_subband, end_subband;
813 
814  /* determine which channels use spx */
815  if (s->channel_mode == AC3_CHMODE_MONO) {
816  s->channel_uses_spx[1] = 1;
817  } else {
818  for (ch = 1; ch <= fbw_channels; ch++)
819  s->channel_uses_spx[ch] = get_bits1(gbc);
820  }
821 
822  /* get the frequency bins of the spx copy region and the spx start
823  and end subbands */
824  dst_start_freq = get_bits(gbc, 2);
825  start_subband = get_bits(gbc, 3) + 2;
826  if (start_subband > 7)
827  start_subband += start_subband - 7;
828  end_subband = get_bits(gbc, 3) + 5;
829  if (end_subband > 7)
830  end_subband += end_subband - 7;
831  dst_start_freq = dst_start_freq * 12 + 25;
832  src_start_freq = start_subband * 12 + 25;
833  dst_end_freq = end_subband * 12 + 25;
834 
835  /* check validity of spx ranges */
836  if (start_subband >= end_subband) {
837  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
838  "range (%d >= %d)\n", start_subband, end_subband);
839  return AVERROR_INVALIDDATA;
840  }
841  if (dst_start_freq >= src_start_freq) {
842  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
843  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
844  return AVERROR_INVALIDDATA;
845  }
846 
847  s->spx_dst_start_freq = dst_start_freq;
848  s->spx_src_start_freq = src_start_freq;
849  s->spx_dst_end_freq = dst_end_freq;
850 
851  decode_band_structure(gbc, blk, s->eac3, 0,
852  start_subband, end_subband,
853  ff_eac3_default_spx_band_struct,
854  &s->num_spx_bands,
855  s->spx_band_sizes);
856  } else {
857  for (ch = 1; ch <= fbw_channels; ch++) {
858  s->channel_uses_spx[ch] = 0;
859  s->first_spx_coords[ch] = 1;
860  }
861  }
862  }
863 
864  /* spectral extension coordinates */
865  if (s->spx_in_use) {
866  for (ch = 1; ch <= fbw_channels; ch++) {
867  if (s->channel_uses_spx[ch]) {
868  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
869  float spx_blend;
870  int bin, master_spx_coord;
871 
872  s->first_spx_coords[ch] = 0;
873  spx_blend = get_bits(gbc, 5) * (1.0f/32);
874  master_spx_coord = get_bits(gbc, 2) * 3;
875 
876  bin = s->spx_src_start_freq;
877  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
878  int bandsize;
879  int spx_coord_exp, spx_coord_mant;
880  float nratio, sblend, nblend, spx_coord;
881 
882  /* calculate blending factors */
883  bandsize = s->spx_band_sizes[bnd];
884  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
885  nratio = av_clipf(nratio, 0.0f, 1.0f);
886  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
887  // to give unity variance
888  sblend = sqrtf(1.0f - nratio);
889  bin += bandsize;
890 
891  /* decode spx coordinates */
892  spx_coord_exp = get_bits(gbc, 4);
893  spx_coord_mant = get_bits(gbc, 2);
894  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
895  else spx_coord_mant += 4;
896  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
897  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
898 
899  /* multiply noise and signal blending factors by spx coordinate */
900  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
901  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
902  }
903  }
904  } else {
905  s->first_spx_coords[ch] = 1;
906  }
907  }
908  }
909 
910  /* coupling strategy */
911  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
912  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
913  if (!s->eac3)
914  s->cpl_in_use[blk] = get_bits1(gbc);
915  if (s->cpl_in_use[blk]) {
916  /* coupling in use */
917  int cpl_start_subband, cpl_end_subband;
918 
919  if (channel_mode < AC3_CHMODE_STEREO) {
920  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
921  return AVERROR_INVALIDDATA;
922  }
923 
924  /* check for enhanced coupling */
925  if (s->eac3 && get_bits1(gbc)) {
926  /* TODO: parse enhanced coupling strategy info */
927  avpriv_request_sample(s->avctx, "Enhanced coupling");
928  return AVERROR_PATCHWELCOME;
929  }
930 
931  /* determine which channels are coupled */
932  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
933  s->channel_in_cpl[1] = 1;
934  s->channel_in_cpl[2] = 1;
935  } else {
936  for (ch = 1; ch <= fbw_channels; ch++)
937  s->channel_in_cpl[ch] = get_bits1(gbc);
938  }
939 
940  /* phase flags in use */
941  if (channel_mode == AC3_CHMODE_STEREO)
942  s->phase_flags_in_use = get_bits1(gbc);
943 
944  /* coupling frequency range */
945  cpl_start_subband = get_bits(gbc, 4);
946  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
947  get_bits(gbc, 4) + 3;
948  if (cpl_start_subband >= cpl_end_subband) {
949  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
950  cpl_start_subband, cpl_end_subband);
951  return AVERROR_INVALIDDATA;
952  }
953  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
954  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
955 
956  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
957  cpl_end_subband,
958  ff_eac3_default_cpl_band_struct,
959  &s->num_cpl_bands, s->cpl_band_sizes);
960  } else {
961  /* coupling not in use */
962  for (ch = 1; ch <= fbw_channels; ch++) {
963  s->channel_in_cpl[ch] = 0;
964  s->first_cpl_coords[ch] = 1;
965  }
966  s->first_cpl_leak = s->eac3;
967  s->phase_flags_in_use = 0;
968  }
969  } else if (!s->eac3) {
970  if (!blk) {
971  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
972  "be present in block 0\n");
973  return AVERROR_INVALIDDATA;
974  } else {
975  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
976  }
977  }
978  cpl_in_use = s->cpl_in_use[blk];
979 
980  /* coupling coordinates */
981  if (cpl_in_use) {
982  int cpl_coords_exist = 0;
983 
984  for (ch = 1; ch <= fbw_channels; ch++) {
985  if (s->channel_in_cpl[ch]) {
986  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
987  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
988  s->first_cpl_coords[ch] = 0;
989  cpl_coords_exist = 1;
990  master_cpl_coord = 3 * get_bits(gbc, 2);
991  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
992  cpl_coord_exp = get_bits(gbc, 4);
993  cpl_coord_mant = get_bits(gbc, 4);
994  if (cpl_coord_exp == 15)
995  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
996  else
997  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
998  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
999  }
1000  } else if (!blk) {
1001  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1002  "be present in block 0\n");
1003  return AVERROR_INVALIDDATA;
1004  }
1005  } else {
1006  /* channel not in coupling */
1007  s->first_cpl_coords[ch] = 1;
1008  }
1009  }
1010  /* phase flags */
1011  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1012  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1013  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1014  }
1015  }
1016  }
1017 
1018  /* stereo rematrixing strategy and band structure */
1019  if (channel_mode == AC3_CHMODE_STEREO) {
1020  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1021  s->num_rematrixing_bands = 4;
1022  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1023  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1024  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1025  s->num_rematrixing_bands--;
1026  }
1027  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1028  s->rematrixing_flags[bnd] = get_bits1(gbc);
1029  } else if (!blk) {
1030  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1031  "new rematrixing strategy not present in block 0\n");
1032  s->num_rematrixing_bands = 0;
1033  }
1034  }
1035 
1036  /* exponent strategies for each channel */
1037  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1038  if (!s->eac3)
1039  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1040  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1041  bit_alloc_stages[ch] = 3;
1042  }
1043 
1044  /* channel bandwidth */
1045  for (ch = 1; ch <= fbw_channels; ch++) {
1046  s->start_freq[ch] = 0;
1047  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1048  int group_size;
1049  int prev = s->end_freq[ch];
1050  if (s->channel_in_cpl[ch])
1051  s->end_freq[ch] = s->start_freq[CPL_CH];
1052  else if (s->channel_uses_spx[ch])
1053  s->end_freq[ch] = s->spx_src_start_freq;
1054  else {
1055  int bandwidth_code = get_bits(gbc, 6);
1056  if (bandwidth_code > 60) {
1057  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1058  return AVERROR_INVALIDDATA;
1059  }
1060  s->end_freq[ch] = bandwidth_code * 3 + 73;
1061  }
1062  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1063  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1064  if (blk > 0 && s->end_freq[ch] != prev)
1065  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1066  }
1067  }
1068  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1069  s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1070  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1071  }
1072 
1073  /* decode exponents for each channel */
1074  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1075  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1076  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1077  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1078  s->num_exp_groups[ch], s->dexps[ch][0],
1079  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1080  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1081  return AVERROR_INVALIDDATA;
1082  }
1083  if (ch != CPL_CH && ch != s->lfe_ch)
1084  skip_bits(gbc, 2); /* skip gainrng */
1085  }
1086  }
1087 
1088  /* bit allocation information */
1089  if (s->bit_allocation_syntax) {
1090  if (get_bits1(gbc)) {
1091  s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1092  s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1093  s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1094  s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1095  s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1096  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1097  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1098  } else if (!blk) {
1099  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1100  "be present in block 0\n");
1101  return AVERROR_INVALIDDATA;
1102  }
1103  }
1104 
1105  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1106  if (!s->eac3 || !blk) {
1107  if (s->snr_offset_strategy && get_bits1(gbc)) {
1108  int snr = 0;
1109  int csnr;
1110  csnr = (get_bits(gbc, 6) - 15) << 4;
1111  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1112  /* snr offset */
1113  if (ch == i || s->snr_offset_strategy == 2)
1114  snr = (csnr + get_bits(gbc, 4)) << 2;
1115  /* run at least last bit allocation stage if snr offset changes */
1116  if (blk && s->snr_offset[ch] != snr) {
1117  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1118  }
1119  s->snr_offset[ch] = snr;
1120 
1121  /* fast gain (normal AC-3 only) */
1122  if (!s->eac3) {
1123  int prev = s->fast_gain[ch];
1124  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1125  /* run last 2 bit allocation stages if fast gain changes */
1126  if (blk && prev != s->fast_gain[ch])
1127  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1128  }
1129  }
1130  } else if (!s->eac3 && !blk) {
1131  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1132  return AVERROR_INVALIDDATA;
1133  }
1134  }
1135 
1136  /* fast gain (E-AC-3 only) */
1137  if (s->fast_gain_syntax && get_bits1(gbc)) {
1138  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1139  int prev = s->fast_gain[ch];
1140  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1141  /* run last 2 bit allocation stages if fast gain changes */
1142  if (blk && prev != s->fast_gain[ch])
1143  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1144  }
1145  } else if (s->eac3 && !blk) {
1146  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1147  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1148  }
1149 
1150  /* E-AC-3 to AC-3 converter SNR offset */
1151  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1152  skip_bits(gbc, 10); // skip converter snr offset
1153  }
1154 
1155  /* coupling leak information */
1156  if (cpl_in_use) {
1157  if (s->first_cpl_leak || get_bits1(gbc)) {
1158  int fl = get_bits(gbc, 3);
1159  int sl = get_bits(gbc, 3);
1160  /* run last 2 bit allocation stages for coupling channel if
1161  coupling leak changes */
1162  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1163  sl != s->bit_alloc_params.cpl_slow_leak)) {
1164  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1165  }
1166  s->bit_alloc_params.cpl_fast_leak = fl;
1167  s->bit_alloc_params.cpl_slow_leak = sl;
1168  } else if (!s->eac3 && !blk) {
1169  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1170  "be present in block 0\n");
1171  return AVERROR_INVALIDDATA;
1172  }
1173  s->first_cpl_leak = 0;
1174  }
1175 
1176  /* delta bit allocation information */
1177  if (s->dba_syntax && get_bits1(gbc)) {
1178  /* delta bit allocation exists (strategy) */
1179  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1180  s->dba_mode[ch] = get_bits(gbc, 2);
1181  if (s->dba_mode[ch] == DBA_RESERVED) {
1182  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1183  return AVERROR_INVALIDDATA;
1184  }
1185  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1186  }
1187  /* channel delta offset, len and bit allocation */
1188  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1189  if (s->dba_mode[ch] == DBA_NEW) {
1190  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1191  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1192  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1193  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1194  s->dba_values[ch][seg] = get_bits(gbc, 3);
1195  }
1196  /* run last 2 bit allocation stages if new dba values */
1197  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1198  }
1199  }
1200  } else if (blk == 0) {
1201  for (ch = 0; ch <= s->channels; ch++) {
1202  s->dba_mode[ch] = DBA_NONE;
1203  }
1204  }
1205 
1206  /* Bit allocation */
1207  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1208  if (bit_alloc_stages[ch] > 2) {
1209  /* Exponent mapping into PSD and PSD integration */
1210  ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1211  s->start_freq[ch], s->end_freq[ch],
1212  s->psd[ch], s->band_psd[ch]);
1213  }
1214  if (bit_alloc_stages[ch] > 1) {
1215  /* Compute excitation function, Compute masking curve, and
1216  Apply delta bit allocation */
1217  if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1218  s->start_freq[ch], s->end_freq[ch],
1219  s->fast_gain[ch], (ch == s->lfe_ch),
1220  s->dba_mode[ch], s->dba_nsegs[ch],
1221  s->dba_offsets[ch], s->dba_lengths[ch],
1222  s->dba_values[ch], s->mask[ch])) {
1223  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1224  return AVERROR_INVALIDDATA;
1225  }
1226  }
1227  if (bit_alloc_stages[ch] > 0) {
1228  /* Compute bit allocation */
1229  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1230  ff_eac3_hebap_tab : ff_ac3_bap_tab;
1231  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1232  s->start_freq[ch], s->end_freq[ch],
1233  s->snr_offset[ch],
1234  s->bit_alloc_params.floor,
1235  bap_tab, s->bap[ch]);
1236  }
1237  }
1238 
1239  /* unused dummy data */
1240  if (s->skip_syntax && get_bits1(gbc)) {
1241  int skipl = get_bits(gbc, 9);
1242  while (skipl--)
1243  skip_bits(gbc, 8);
1244  }
1245 
1246  /* unpack the transform coefficients
1247  this also uncouples channels if coupling is in use. */
1248  decode_transform_coeffs(s, blk);
1249 
1250  /* TODO: generate enhanced coupling coordinates and uncouple */
1251 
1252  /* recover coefficients if rematrixing is in use */
1253  if (s->channel_mode == AC3_CHMODE_STEREO)
1254  do_rematrixing(s);
1255 
1256  /* apply scaling to coefficients (headroom, dynrng) */
1257  for (ch = 1; ch <= s->channels; ch++) {
1258  float gain = 1.0 / 4194304.0f;
1259  if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1260  gain *= s->dynamic_range[2 - ch];
1261  } else {
1262  gain *= s->dynamic_range[0];
1263  }
1264  s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1265  s->fixed_coeffs[ch], gain, 256);
1266  }
1267 
1268  /* apply spectral extension to high frequency bins */
1269  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1270  ff_eac3_apply_spectral_extension(s);
1271  }
1272 
1273  /* downmix and MDCT. order depends on whether block switching is used for
1274  any channel in this block. this is because coefficients for the long
1275  and short transforms cannot be mixed. */
1276  downmix_output = s->channels != s->out_channels &&
1277  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1278  s->fbw_channels == s->out_channels);
1279  if (different_transforms) {
1280  /* the delay samples have already been downmixed, so we upmix the delay
1281  samples in order to reconstruct all channels before downmixing. */
1282  if (s->downmixed) {
1283  s->downmixed = 0;
1284  ac3_upmix_delay(s);
1285  }
1286 
1287  do_imdct(s, s->channels);
1288 
1289  if (downmix_output) {
1290  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1291  s->out_channels, s->fbw_channels, 256);
1292  }
1293  } else {
1294  if (downmix_output) {
1295  s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1296  s->out_channels, s->fbw_channels, 256);
1297  }
1298 
1299  if (downmix_output && !s->downmixed) {
1300  s->downmixed = 1;
1301  s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1302  s->fbw_channels, 128);
1303  }
1304 
1305  do_imdct(s, s->out_channels);
1306  }
1307 
1308  return 0;
1309 }
1310 
1311 /**
1312  * Decode a single AC-3 frame.
1313  */
1314 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1315  int *got_frame_ptr, AVPacket *avpkt)
1316 {
1317  AVFrame *frame = data;
1318  const uint8_t *buf = avpkt->data;
1319  int buf_size = avpkt->size;
1320  AC3DecodeContext *s = avctx->priv_data;
1321  int blk, ch, err, ret;
1322  const uint8_t *channel_map;
1323  const float *output[AC3_MAX_CHANNELS];
1324  enum AVMatrixEncoding matrix_encoding;
1325  AVDownmixInfo *downmix_info;
1326 
1327  /* copy input buffer to decoder context to avoid reading past the end
1328  of the buffer, which can be caused by a damaged input stream. */
1329  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1330  // seems to be byte-swapped AC-3
1331  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1332  s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1333  } else
1334  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1335  buf = s->input_buffer;
1336  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1337  init_get_bits(&s->gbc, buf, buf_size * 8);
1338 
1339  /* parse the syncinfo */
1340  err = parse_frame_header(s);
1341 
1342  if (err) {
1343  switch (err) {
1344  case AAC_AC3_PARSE_ERROR_SYNC:
1345  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1346  return AVERROR_INVALIDDATA;
1347  case AAC_AC3_PARSE_ERROR_BSID:
1348  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1349  break;
1350  case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1351  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1352  break;
1353  case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1354  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1355  break;
1356  case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1357  /* skip frame if CRC is ok. otherwise use error concealment. */
1358  /* TODO: add support for substreams and dependent frames */
1359  if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1360  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1361  "skipping frame\n");
1362  *got_frame_ptr = 0;
1363  return buf_size;
1364  } else {
1365  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1366  }
1367  break;
1368  case AAC_AC3_PARSE_ERROR_CRC:
1369  case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1370  break;
1371  default: // Normal AVERROR do not try to recover.
1372  *got_frame_ptr = 0;
1373  return err;
1374  }
1375  } else {
1376  /* check that reported frame size fits in input buffer */
1377  if (s->frame_size > buf_size) {
1378  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1379  err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1380  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1381  /* check for crc mismatch */
1382  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1383  s->frame_size - 2)) {
1384  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1385  if (avctx->err_recognition & AV_EF_EXPLODE)
1386  return AVERROR_INVALIDDATA;
1387  err = AAC_AC3_PARSE_ERROR_CRC;
1388  }
1389  }
1390  }
1391 
1392  /* if frame is ok, set audio parameters */
1393  if (!err) {
1394  avctx->sample_rate = s->sample_rate;
1395  avctx->bit_rate = s->bit_rate;
1396  }
1397 
1398  /* channel config */
1399  if (!err || (s->channels && s->out_channels != s->channels)) {
1400  s->out_channels = s->channels;
1401  s->output_mode = s->channel_mode;
1402  if (s->lfe_on)
1403  s->output_mode |= AC3_OUTPUT_LFEON;
1404  if (s->channels > 1 &&
1405  avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1406  s->out_channels = 1;
1407  s->output_mode = AC3_CHMODE_MONO;
1408  } else if (s->channels > 2 &&
1409  avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1410  s->out_channels = 2;
1411  s->output_mode = AC3_CHMODE_STEREO;
1412  }
1413 
1414  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1415  s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1416  s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1417  s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1418  /* set downmixing coefficients if needed */
1419  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1420  s->fbw_channels == s->out_channels)) {
1421  set_downmix_coeffs(s);
1422  }
1423  } else if (!s->channels) {
1424  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1425  return AVERROR_INVALIDDATA;
1426  }
1427  avctx->channels = s->out_channels;
1428  avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1429  if (s->output_mode & AC3_OUTPUT_LFEON)
1430  avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1431 
1432  /* set audio service type based on bitstream mode for AC-3 */
1433  avctx->audio_service_type = s->bitstream_mode;
1434  if (s->bitstream_mode == 0x7 && s->channels > 1)
1435  avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1436 
1437  /* get output buffer */
1438  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1439  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1440  return ret;
1441 
1442  /* decode the audio blocks */
1443  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1444  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1445  output[ch] = s->output[ch];
1446  s->outptr[ch] = s->output[ch];
1447  }
1448  for (ch = 0; ch < s->channels; ch++) {
1449  if (ch < s->out_channels)
1450  s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1451  }
1452  for (blk = 0; blk < s->num_blocks; blk++) {
1453  if (!err && decode_audio_block(s, blk)) {
1454  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1455  err = 1;
1456  }
1457  if (err)
1458  for (ch = 0; ch < s->out_channels; ch++)
1459  memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1460  for (ch = 0; ch < s->out_channels; ch++)
1461  output[ch] = s->outptr[channel_map[ch]];
1462  for (ch = 0; ch < s->out_channels; ch++) {
1463  if (!ch || channel_map[ch])
1464  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1465  }
1466  }
1467 
1468  av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1469 
1470  /* keep last block for error concealment in next frame */
1471  for (ch = 0; ch < s->out_channels; ch++)
1472  memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1473 
1474  /*
1475  * AVMatrixEncoding
1476  *
1477  * Check whether the input layout is compatible, and make sure we're not
1478  * downmixing (else the matrix encoding is no longer applicable).
1479  */
1480  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1481  if (s->channel_mode == AC3_CHMODE_STEREO &&
1482  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1483  if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1484  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1485  else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1486  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1487  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1488  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1489  switch (s->dolby_surround_ex_mode) {
1490  case AC3_DSUREXMOD_ON: // EX or PLIIx
1491  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1492  break;
1493  case AC3_DSUREXMOD_PLIIZ:
1494  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1495  break;
1496  default: // not indicated or off
1497  break;
1498  }
1499  }
1500  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1501  return ret;
1502 
1503  /* AVDownmixInfo */
1504  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1505  switch (s->preferred_downmix) {
1506  case AC3_DMIXMOD_LTRT:
1507  downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1508  break;
1509  case AC3_DMIXMOD_LORO:
1510  downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1511  break;
1512  case AC3_DMIXMOD_DPLII:
1513  downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1514  break;
1515  default:
1516  downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1517  break;
1518  }
1519  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1520  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1521  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1522  downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1523  if (s->lfe_mix_level_exists)
1524  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1525  else
1526  downmix_info->lfe_mix_level = 0.0; // -inf dB
1527  } else
1528  return AVERROR(ENOMEM);
1529 
1530  *got_frame_ptr = 1;
1531 
1532  return FFMIN(buf_size, s->frame_size);
1533 }
1534 
1535 /**
1536  * Uninitialize the AC-3 decoder.
1537  */
1538 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1539 {
1540  AC3DecodeContext *s = avctx->priv_data;
1541  ff_mdct_end(&s->imdct_512);
1542  ff_mdct_end(&s->imdct_256);
1543 
1544  return 0;
1545 }
1546 
1547 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1548 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1549 static const AVOption options[] = {
1550  { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1551 
1552 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1553 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1554 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1555 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1556 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1557 
1558  { NULL},
1559 };
1560 
1561 static const AVClass ac3_decoder_class = {
1562  .class_name = "AC3 decoder",
1563  .item_name = av_default_item_name,
1564  .option = options,
1565  .version = LIBAVUTIL_VERSION_INT,
1566 };
1567 
1568 AVCodec ff_ac3_decoder = {
1569  .name = "ac3",
1570  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1571  .type = AVMEDIA_TYPE_AUDIO,
1572  .id = AV_CODEC_ID_AC3,
1573  .priv_data_size = sizeof (AC3DecodeContext),
1574  .init = ac3_decode_init,
1575  .close = ac3_decode_end,
1576  .decode = ac3_decode_frame,
1577  .capabilities = CODEC_CAP_DR1,
1578  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1579  AV_SAMPLE_FMT_NONE },
1580  .priv_class = &ac3_decoder_class,
1581 };
1582 
1583 #if CONFIG_EAC3_DECODER
1584 static const AVClass eac3_decoder_class = {
1585  .class_name = "E-AC3 decoder",
1586  .item_name = av_default_item_name,
1587  .option = options,
1588  .version = LIBAVUTIL_VERSION_INT,
1589 };
1590 
1591 AVCodec ff_eac3_decoder = {
1592  .name = "eac3",
1593  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1594  .type = AVMEDIA_TYPE_AUDIO,
1595  .id = AV_CODEC_ID_EAC3,
1596  .priv_data_size = sizeof (AC3DecodeContext),
1597  .init = ac3_decode_init,
1598  .close = ac3_decode_end,
1599  .decode = ac3_decode_frame,
1600  .capabilities = CODEC_CAP_DR1,
1601  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1602  AV_SAMPLE_FMT_NONE },
1603  .priv_class = &eac3_decoder_class,
1604 };
1605 #endif
Generated on Sun Mar 23 2014 23:49:50 for FFmpeg by   doxygen 1.8.2