Libav
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 Libav.
11  *
12  * Libav 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  * Libav 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 Libav; 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 
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 
48 
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 
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 
66 static float dynamic_range_tab[256];
67 
69 static const float gain_levels[9] = {
72  LEVEL_ONE,
77  LEVEL_ZERO,
79 };
80 
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 
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 
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 */
138  }
139  for (i = 0; i < 128; i++) {
140  /* bap=2 mantissas */
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 
172 {
173  AC3DecodeContext *s = avctx->priv_data;
174  int i;
175 
176  s->avctx = avctx;
177 
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);
186  ff_fmt_convert_init(&s->fmt_conv, avctx);
187  av_lfg_init(&s->dith_state, 0);
188 
190 
191  /* allow downmixing to stereo or mono */
192 #if FF_API_REQUEST_CHANNELS
194  if (avctx->request_channels == 1)
196  else if (avctx->request_channels == 2)
199 #endif
200  if (avctx->channels > 1 &&
202  avctx->channels = 1;
203  else if (avctx->channels > 2 &&
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 
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 
276 {
277  AC3HeaderInfo hdr;
278  int err;
279 
280  err = avpriv_ac3_parse_header(&s->gbc, &hdr);
281  if (err)
282  return err;
283 
284  /* get decoding parameters from header info */
286  s->bitstream_id = hdr.bitstream_id;
288  s->channel_mode = hdr.channel_mode;
289  s->lfe_on = hdr.lfe_on;
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;
299  s->center_mix_level_ltrt = 4; // -3.0dB
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;
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 
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++) {
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  }
357  int nf = s->channel_mode - 2;
358  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
359  }
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 
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 
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 
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 
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) / 362) - 5932275;
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  mantissa = get_sbits(gbc, quantization_tab[bap]);
533  mantissa <<= 24 - quantization_tab[bap];
534  break;
535  }
536  coeffs[freq] = mantissa >> exps[freq];
537  }
538 }
539 
546  int ch, i;
547 
548  for (ch = 1; ch <= s->fbw_channels; ch++) {
549  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
550  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
551  if (!s->bap[CPL_CH][i])
552  s->fixed_coeffs[ch][i] = 0;
553  }
554  }
555  }
556 }
557 
558 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
559  mant_groups *m)
560 {
561  if (!s->channel_uses_aht[ch]) {
563  } else {
564  /* if AHT is used, mantissas for all blocks are encoded in the first
565  block of the frame. */
566  int bin;
567  if (!blk && CONFIG_EAC3_DECODER)
569  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
570  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
571  }
572  }
573 }
574 
579 {
580  int ch, end;
581  int got_cplchan = 0;
582  mant_groups m;
583 
584  m.b1 = m.b2 = m.b4 = 0;
585 
586  for (ch = 1; ch <= s->channels; ch++) {
587  /* transform coefficients for full-bandwidth channel */
588  decode_transform_coeffs_ch(s, blk, ch, &m);
589  /* transform coefficients for coupling channel come right after the
590  coefficients for the first coupled channel*/
591  if (s->channel_in_cpl[ch]) {
592  if (!got_cplchan) {
593  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
595  got_cplchan = 1;
596  }
597  end = s->end_freq[CPL_CH];
598  } else {
599  end = s->end_freq[ch];
600  }
601  do
602  s->fixed_coeffs[ch][end] = 0;
603  while (++end < 256);
604  }
605 
606  /* zero the dithered coefficients for appropriate channels */
607  remove_dithering(s);
608 }
609 
615 {
616  int bnd, i;
617  int end, bndend;
618 
619  end = FFMIN(s->end_freq[1], s->end_freq[2]);
620 
621  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
622  if (s->rematrixing_flags[bnd]) {
623  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
624  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
625  int tmp0 = s->fixed_coeffs[1][i];
626  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
627  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
628  }
629  }
630  }
631 }
632 
638 static inline void do_imdct(AC3DecodeContext *s, int channels)
639 {
640  int ch;
641 
642  for (ch = 1; ch <= channels; ch++) {
643  if (s->block_switch[ch]) {
644  int i;
645  float *x = s->tmp_output + 128;
646  for (i = 0; i < 128; i++)
647  x[i] = s->transform_coeffs[ch][2 * i];
648  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
649  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
650  s->tmp_output, s->window, 128);
651  for (i = 0; i < 128; i++)
652  x[i] = s->transform_coeffs[ch][2 * i + 1];
653  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
654  } else {
656  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
657  s->tmp_output, s->window, 128);
658  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
659  }
660  }
661 }
662 
667 {
668  int channel_data_size = sizeof(s->delay[0]);
669  switch (s->channel_mode) {
670  case AC3_CHMODE_DUALMONO:
671  case AC3_CHMODE_STEREO:
672  /* upmix mono to stereo */
673  memcpy(s->delay[1], s->delay[0], channel_data_size);
674  break;
675  case AC3_CHMODE_2F2R:
676  memset(s->delay[3], 0, channel_data_size);
677  case AC3_CHMODE_2F1R:
678  memset(s->delay[2], 0, channel_data_size);
679  break;
680  case AC3_CHMODE_3F2R:
681  memset(s->delay[4], 0, channel_data_size);
682  case AC3_CHMODE_3F1R:
683  memset(s->delay[3], 0, channel_data_size);
684  case AC3_CHMODE_3F:
685  memcpy(s->delay[2], s->delay[1], channel_data_size);
686  memset(s->delay[1], 0, channel_data_size);
687  break;
688  }
689 }
690 
707 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
708  int ecpl, int start_subband, int end_subband,
709  const uint8_t *default_band_struct,
710  int *num_bands, uint8_t *band_sizes)
711 {
712  int subbnd, bnd, n_subbands, n_bands=0;
713  uint8_t bnd_sz[22];
714  uint8_t coded_band_struct[22];
715  const uint8_t *band_struct;
716 
717  n_subbands = end_subband - start_subband;
718 
719  /* decode band structure from bitstream or use default */
720  if (!eac3 || get_bits1(gbc)) {
721  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
722  coded_band_struct[subbnd] = get_bits1(gbc);
723  }
724  band_struct = coded_band_struct;
725  } else if (!blk) {
726  band_struct = &default_band_struct[start_subband+1];
727  } else {
728  /* no change in band structure */
729  return;
730  }
731 
732  /* calculate number of bands and band sizes based on band structure.
733  note that the first 4 subbands in enhanced coupling span only 6 bins
734  instead of 12. */
735  if (num_bands || band_sizes ) {
736  n_bands = n_subbands;
737  bnd_sz[0] = ecpl ? 6 : 12;
738  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
739  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
740  if (band_struct[subbnd - 1]) {
741  n_bands--;
742  bnd_sz[bnd] += subbnd_size;
743  } else {
744  bnd_sz[++bnd] = subbnd_size;
745  }
746  }
747  }
748 
749  /* set optional output params */
750  if (num_bands)
751  *num_bands = n_bands;
752  if (band_sizes)
753  memcpy(band_sizes, bnd_sz, n_bands);
754 }
755 
760 {
761  int fbw_channels = s->fbw_channels;
762  int channel_mode = s->channel_mode;
763  int i, bnd, seg, ch;
764  int different_transforms;
765  int downmix_output;
766  int cpl_in_use;
767  GetBitContext *gbc = &s->gbc;
768  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
769 
770  /* block switch flags */
771  different_transforms = 0;
772  if (s->block_switch_syntax) {
773  for (ch = 1; ch <= fbw_channels; ch++) {
774  s->block_switch[ch] = get_bits1(gbc);
775  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
776  different_transforms = 1;
777  }
778  }
779 
780  /* dithering flags */
781  if (s->dither_flag_syntax) {
782  for (ch = 1; ch <= fbw_channels; ch++) {
783  s->dither_flag[ch] = get_bits1(gbc);
784  }
785  }
786 
787  /* dynamic range */
788  i = !s->channel_mode;
789  do {
790  if (get_bits1(gbc)) {
791  /* Allow asymmetric application of DRC when drc_scale > 1.
792  Amplification of quiet sounds is enhanced */
793  float range = dynamic_range_tab[get_bits(gbc, 8)];
794  if (range > 1.0 || s->drc_scale <= 1.0)
795  s->dynamic_range[i] = powf(range, s->drc_scale);
796  else
797  s->dynamic_range[i] = range;
798  } else if (blk == 0) {
799  s->dynamic_range[i] = 1.0f;
800  }
801  } while (i--);
802 
803  /* spectral extension strategy */
804  if (s->eac3 && (!blk || get_bits1(gbc))) {
805  s->spx_in_use = get_bits1(gbc);
806  if (s->spx_in_use) {
807  int dst_start_freq, dst_end_freq, src_start_freq,
808  start_subband, end_subband;
809 
810  /* determine which channels use spx */
811  if (s->channel_mode == AC3_CHMODE_MONO) {
812  s->channel_uses_spx[1] = 1;
813  } else {
814  for (ch = 1; ch <= fbw_channels; ch++)
815  s->channel_uses_spx[ch] = get_bits1(gbc);
816  }
817 
818  /* get the frequency bins of the spx copy region and the spx start
819  and end subbands */
820  dst_start_freq = get_bits(gbc, 2);
821  start_subband = get_bits(gbc, 3) + 2;
822  if (start_subband > 7)
823  start_subband += start_subband - 7;
824  end_subband = get_bits(gbc, 3) + 5;
825  if (end_subband > 7)
826  end_subband += end_subband - 7;
827  dst_start_freq = dst_start_freq * 12 + 25;
828  src_start_freq = start_subband * 12 + 25;
829  dst_end_freq = end_subband * 12 + 25;
830 
831  /* check validity of spx ranges */
832  if (start_subband >= end_subband) {
833  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
834  "range (%d >= %d)\n", start_subband, end_subband);
835  return AVERROR_INVALIDDATA;
836  }
837  if (dst_start_freq >= src_start_freq) {
838  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
839  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
840  return AVERROR_INVALIDDATA;
841  }
842 
843  s->spx_dst_start_freq = dst_start_freq;
844  s->spx_src_start_freq = src_start_freq;
845  s->spx_dst_end_freq = dst_end_freq;
846 
847  decode_band_structure(gbc, blk, s->eac3, 0,
848  start_subband, end_subband,
850  &s->num_spx_bands,
851  s->spx_band_sizes);
852  } else {
853  for (ch = 1; ch <= fbw_channels; ch++) {
854  s->channel_uses_spx[ch] = 0;
855  s->first_spx_coords[ch] = 1;
856  }
857  }
858  }
859 
860  /* spectral extension coordinates */
861  if (s->spx_in_use) {
862  for (ch = 1; ch <= fbw_channels; ch++) {
863  if (s->channel_uses_spx[ch]) {
864  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
865  float spx_blend;
866  int bin, master_spx_coord;
867 
868  s->first_spx_coords[ch] = 0;
869  spx_blend = get_bits(gbc, 5) * (1.0f/32);
870  master_spx_coord = get_bits(gbc, 2) * 3;
871 
872  bin = s->spx_src_start_freq;
873  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
874  int bandsize;
875  int spx_coord_exp, spx_coord_mant;
876  float nratio, sblend, nblend, spx_coord;
877 
878  /* calculate blending factors */
879  bandsize = s->spx_band_sizes[bnd];
880  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
881  nratio = av_clipf(nratio, 0.0f, 1.0f);
882  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
883  // to give unity variance
884  sblend = sqrtf(1.0f - nratio);
885  bin += bandsize;
886 
887  /* decode spx coordinates */
888  spx_coord_exp = get_bits(gbc, 4);
889  spx_coord_mant = get_bits(gbc, 2);
890  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
891  else spx_coord_mant += 4;
892  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
893  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
894 
895  /* multiply noise and signal blending factors by spx coordinate */
896  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
897  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
898  }
899  }
900  } else {
901  s->first_spx_coords[ch] = 1;
902  }
903  }
904  }
905 
906  /* coupling strategy */
907  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
908  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
909  if (!s->eac3)
910  s->cpl_in_use[blk] = get_bits1(gbc);
911  if (s->cpl_in_use[blk]) {
912  /* coupling in use */
913  int cpl_start_subband, cpl_end_subband;
914 
915  if (channel_mode < AC3_CHMODE_STEREO) {
916  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
917  return AVERROR_INVALIDDATA;
918  }
919 
920  /* check for enhanced coupling */
921  if (s->eac3 && get_bits1(gbc)) {
922  /* TODO: parse enhanced coupling strategy info */
923  avpriv_request_sample(s->avctx, "Enhanced coupling");
924  return AVERROR_PATCHWELCOME;
925  }
926 
927  /* determine which channels are coupled */
928  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
929  s->channel_in_cpl[1] = 1;
930  s->channel_in_cpl[2] = 1;
931  } else {
932  for (ch = 1; ch <= fbw_channels; ch++)
933  s->channel_in_cpl[ch] = get_bits1(gbc);
934  }
935 
936  /* phase flags in use */
937  if (channel_mode == AC3_CHMODE_STEREO)
938  s->phase_flags_in_use = get_bits1(gbc);
939 
940  /* coupling frequency range */
941  cpl_start_subband = get_bits(gbc, 4);
942  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
943  get_bits(gbc, 4) + 3;
944  if (cpl_start_subband >= cpl_end_subband) {
945  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
946  cpl_start_subband, cpl_end_subband);
947  return AVERROR_INVALIDDATA;
948  }
949  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
950  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
951 
952  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
953  cpl_end_subband,
955  &s->num_cpl_bands, s->cpl_band_sizes);
956  } else {
957  /* coupling not in use */
958  for (ch = 1; ch <= fbw_channels; ch++) {
959  s->channel_in_cpl[ch] = 0;
960  s->first_cpl_coords[ch] = 1;
961  }
962  s->first_cpl_leak = s->eac3;
963  s->phase_flags_in_use = 0;
964  }
965  } else if (!s->eac3) {
966  if (!blk) {
967  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
968  "be present in block 0\n");
969  return AVERROR_INVALIDDATA;
970  } else {
971  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
972  }
973  }
974  cpl_in_use = s->cpl_in_use[blk];
975 
976  /* coupling coordinates */
977  if (cpl_in_use) {
978  int cpl_coords_exist = 0;
979 
980  for (ch = 1; ch <= fbw_channels; ch++) {
981  if (s->channel_in_cpl[ch]) {
982  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
983  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
984  s->first_cpl_coords[ch] = 0;
985  cpl_coords_exist = 1;
986  master_cpl_coord = 3 * get_bits(gbc, 2);
987  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
988  cpl_coord_exp = get_bits(gbc, 4);
989  cpl_coord_mant = get_bits(gbc, 4);
990  if (cpl_coord_exp == 15)
991  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
992  else
993  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
994  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
995  }
996  } else if (!blk) {
997  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
998  "be present in block 0\n");
999  return AVERROR_INVALIDDATA;
1000  }
1001  } else {
1002  /* channel not in coupling */
1003  s->first_cpl_coords[ch] = 1;
1004  }
1005  }
1006  /* phase flags */
1007  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1008  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1009  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1010  }
1011  }
1012  }
1013 
1014  /* stereo rematrixing strategy and band structure */
1015  if (channel_mode == AC3_CHMODE_STEREO) {
1016  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1017  s->num_rematrixing_bands = 4;
1018  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1019  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1020  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1021  s->num_rematrixing_bands--;
1022  }
1023  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1024  s->rematrixing_flags[bnd] = get_bits1(gbc);
1025  } else if (!blk) {
1026  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1027  "new rematrixing strategy not present in block 0\n");
1028  s->num_rematrixing_bands = 0;
1029  }
1030  }
1031 
1032  /* exponent strategies for each channel */
1033  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1034  if (!s->eac3)
1035  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1036  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1037  bit_alloc_stages[ch] = 3;
1038  }
1039 
1040  /* channel bandwidth */
1041  for (ch = 1; ch <= fbw_channels; ch++) {
1042  s->start_freq[ch] = 0;
1043  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1044  int group_size;
1045  int prev = s->end_freq[ch];
1046  if (s->channel_in_cpl[ch])
1047  s->end_freq[ch] = s->start_freq[CPL_CH];
1048  else if (s->channel_uses_spx[ch])
1049  s->end_freq[ch] = s->spx_src_start_freq;
1050  else {
1051  int bandwidth_code = get_bits(gbc, 6);
1052  if (bandwidth_code > 60) {
1053  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1054  return AVERROR_INVALIDDATA;
1055  }
1056  s->end_freq[ch] = bandwidth_code * 3 + 73;
1057  }
1058  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1059  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1060  if (blk > 0 && s->end_freq[ch] != prev)
1061  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1062  }
1063  }
1064  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1066  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1067  }
1068 
1069  /* decode exponents for each channel */
1070  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1071  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1072  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1073  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1074  s->num_exp_groups[ch], s->dexps[ch][0],
1075  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1076  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1077  return AVERROR_INVALIDDATA;
1078  }
1079  if (ch != CPL_CH && ch != s->lfe_ch)
1080  skip_bits(gbc, 2); /* skip gainrng */
1081  }
1082  }
1083 
1084  /* bit allocation information */
1085  if (s->bit_allocation_syntax) {
1086  if (get_bits1(gbc)) {
1092  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1093  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1094  } else if (!blk) {
1095  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1096  "be present in block 0\n");
1097  return AVERROR_INVALIDDATA;
1098  }
1099  }
1100 
1101  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1102  if (!s->eac3 || !blk) {
1103  if (s->snr_offset_strategy && get_bits1(gbc)) {
1104  int snr = 0;
1105  int csnr;
1106  csnr = (get_bits(gbc, 6) - 15) << 4;
1107  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1108  /* snr offset */
1109  if (ch == i || s->snr_offset_strategy == 2)
1110  snr = (csnr + get_bits(gbc, 4)) << 2;
1111  /* run at least last bit allocation stage if snr offset changes */
1112  if (blk && s->snr_offset[ch] != snr) {
1113  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1114  }
1115  s->snr_offset[ch] = snr;
1116 
1117  /* fast gain (normal AC-3 only) */
1118  if (!s->eac3) {
1119  int prev = s->fast_gain[ch];
1120  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1121  /* run last 2 bit allocation stages if fast gain changes */
1122  if (blk && prev != s->fast_gain[ch])
1123  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1124  }
1125  }
1126  } else if (!s->eac3 && !blk) {
1127  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1128  return AVERROR_INVALIDDATA;
1129  }
1130  }
1131 
1132  /* fast gain (E-AC-3 only) */
1133  if (s->fast_gain_syntax && get_bits1(gbc)) {
1134  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1135  int prev = s->fast_gain[ch];
1136  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1137  /* run last 2 bit allocation stages if fast gain changes */
1138  if (blk && prev != s->fast_gain[ch])
1139  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1140  }
1141  } else if (s->eac3 && !blk) {
1142  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1143  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1144  }
1145 
1146  /* E-AC-3 to AC-3 converter SNR offset */
1147  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1148  skip_bits(gbc, 10); // skip converter snr offset
1149  }
1150 
1151  /* coupling leak information */
1152  if (cpl_in_use) {
1153  if (s->first_cpl_leak || get_bits1(gbc)) {
1154  int fl = get_bits(gbc, 3);
1155  int sl = get_bits(gbc, 3);
1156  /* run last 2 bit allocation stages for coupling channel if
1157  coupling leak changes */
1158  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1159  sl != s->bit_alloc_params.cpl_slow_leak)) {
1160  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1161  }
1164  } else if (!s->eac3 && !blk) {
1165  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1166  "be present in block 0\n");
1167  return AVERROR_INVALIDDATA;
1168  }
1169  s->first_cpl_leak = 0;
1170  }
1171 
1172  /* delta bit allocation information */
1173  if (s->dba_syntax && get_bits1(gbc)) {
1174  /* delta bit allocation exists (strategy) */
1175  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1176  s->dba_mode[ch] = get_bits(gbc, 2);
1177  if (s->dba_mode[ch] == DBA_RESERVED) {
1178  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1179  return AVERROR_INVALIDDATA;
1180  }
1181  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1182  }
1183  /* channel delta offset, len and bit allocation */
1184  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1185  if (s->dba_mode[ch] == DBA_NEW) {
1186  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1187  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1188  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1189  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1190  s->dba_values[ch][seg] = get_bits(gbc, 3);
1191  }
1192  /* run last 2 bit allocation stages if new dba values */
1193  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1194  }
1195  }
1196  } else if (blk == 0) {
1197  for (ch = 0; ch <= s->channels; ch++) {
1198  s->dba_mode[ch] = DBA_NONE;
1199  }
1200  }
1201 
1202  /* Bit allocation */
1203  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1204  if (bit_alloc_stages[ch] > 2) {
1205  /* Exponent mapping into PSD and PSD integration */
1207  s->start_freq[ch], s->end_freq[ch],
1208  s->psd[ch], s->band_psd[ch]);
1209  }
1210  if (bit_alloc_stages[ch] > 1) {
1211  /* Compute excitation function, Compute masking curve, and
1212  Apply delta bit allocation */
1214  s->start_freq[ch], s->end_freq[ch],
1215  s->fast_gain[ch], (ch == s->lfe_ch),
1216  s->dba_mode[ch], s->dba_nsegs[ch],
1217  s->dba_offsets[ch], s->dba_lengths[ch],
1218  s->dba_values[ch], s->mask[ch])) {
1219  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1220  return AVERROR_INVALIDDATA;
1221  }
1222  }
1223  if (bit_alloc_stages[ch] > 0) {
1224  /* Compute bit allocation */
1225  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1227  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1228  s->start_freq[ch], s->end_freq[ch],
1229  s->snr_offset[ch],
1231  bap_tab, s->bap[ch]);
1232  }
1233  }
1234 
1235  /* unused dummy data */
1236  if (s->skip_syntax && get_bits1(gbc)) {
1237  int skipl = get_bits(gbc, 9);
1238  while (skipl--)
1239  skip_bits(gbc, 8);
1240  }
1241 
1242  /* unpack the transform coefficients
1243  this also uncouples channels if coupling is in use. */
1244  decode_transform_coeffs(s, blk);
1245 
1246  /* TODO: generate enhanced coupling coordinates and uncouple */
1247 
1248  /* recover coefficients if rematrixing is in use */
1249  if (s->channel_mode == AC3_CHMODE_STEREO)
1250  do_rematrixing(s);
1251 
1252  /* apply scaling to coefficients (headroom, dynrng) */
1253  for (ch = 1; ch <= s->channels; ch++) {
1254  float gain = 1.0 / 4194304.0f;
1255  if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1256  gain *= s->dynamic_range[2 - ch];
1257  } else {
1258  gain *= s->dynamic_range[0];
1259  }
1261  s->fixed_coeffs[ch], gain, 256);
1262  }
1263 
1264  /* apply spectral extension to high frequency bins */
1265  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1267  }
1268 
1269  /* downmix and MDCT. order depends on whether block switching is used for
1270  any channel in this block. this is because coefficients for the long
1271  and short transforms cannot be mixed. */
1272  downmix_output = s->channels != s->out_channels &&
1273  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1274  s->fbw_channels == s->out_channels);
1275  if (different_transforms) {
1276  /* the delay samples have already been downmixed, so we upmix the delay
1277  samples in order to reconstruct all channels before downmixing. */
1278  if (s->downmixed) {
1279  s->downmixed = 0;
1280  ac3_upmix_delay(s);
1281  }
1282 
1283  do_imdct(s, s->channels);
1284 
1285  if (downmix_output) {
1286  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1287  s->out_channels, s->fbw_channels, 256);
1288  }
1289  } else {
1290  if (downmix_output) {
1291  s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1292  s->out_channels, s->fbw_channels, 256);
1293  }
1294 
1295  if (downmix_output && !s->downmixed) {
1296  s->downmixed = 1;
1298  s->fbw_channels, 128);
1299  }
1300 
1301  do_imdct(s, s->out_channels);
1302  }
1303 
1304  return 0;
1305 }
1306 
1310 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1311  int *got_frame_ptr, AVPacket *avpkt)
1312 {
1313  AVFrame *frame = data;
1314  const uint8_t *buf = avpkt->data;
1315  int buf_size = avpkt->size;
1316  AC3DecodeContext *s = avctx->priv_data;
1317  int blk, ch, err, ret;
1318  const uint8_t *channel_map;
1319  const float *output[AC3_MAX_CHANNELS];
1320  enum AVMatrixEncoding matrix_encoding;
1321  AVDownmixInfo *downmix_info;
1322 
1323  /* copy input buffer to decoder context to avoid reading past the end
1324  of the buffer, which can be caused by a damaged input stream. */
1325  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1326  // seems to be byte-swapped AC-3
1327  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1328  s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1329  } else
1330  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1331  buf = s->input_buffer;
1332  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1333  init_get_bits(&s->gbc, buf, buf_size * 8);
1334 
1335  /* parse the syncinfo */
1336  err = parse_frame_header(s);
1337 
1338  if (err) {
1339  switch (err) {
1341  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1342  return AVERROR_INVALIDDATA;
1344  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1345  break;
1347  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1348  break;
1350  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1351  break;
1353  /* skip frame if CRC is ok. otherwise use error concealment. */
1354  /* TODO: add support for substreams and dependent frames */
1356  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1357  "skipping frame\n");
1358  *got_frame_ptr = 0;
1359  return buf_size;
1360  } else {
1361  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1362  }
1363  break;
1366  break;
1367  default: // Normal AVERROR do not try to recover.
1368  *got_frame_ptr = 0;
1369  return err;
1370  }
1371  } else {
1372  /* check that reported frame size fits in input buffer */
1373  if (s->frame_size > buf_size) {
1374  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1376  } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1377  /* check for crc mismatch */
1378  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1379  s->frame_size - 2)) {
1380  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1381  if (avctx->err_recognition & AV_EF_EXPLODE)
1382  return AVERROR_INVALIDDATA;
1384  }
1385  }
1386  }
1387 
1388  /* if frame is ok, set audio parameters */
1389  if (!err) {
1390  avctx->sample_rate = s->sample_rate;
1391  avctx->bit_rate = s->bit_rate;
1392  }
1393 
1394  /* channel config */
1395  if (!err || (s->channels && s->out_channels != s->channels)) {
1396  s->out_channels = s->channels;
1397  s->output_mode = s->channel_mode;
1398  if (s->lfe_on)
1400  if (s->channels > 1 &&
1402  s->out_channels = 1;
1404  } else if (s->channels > 2 &&
1406  s->out_channels = 2;
1408  }
1409 
1410  /* set downmixing coefficients if needed */
1411  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1412  s->fbw_channels == s->out_channels)) {
1413  set_downmix_coeffs(s);
1414  }
1415  } else if (!s->channels) {
1416  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1417  return AVERROR_INVALIDDATA;
1418  }
1419  avctx->channels = s->out_channels;
1421  if (s->output_mode & AC3_OUTPUT_LFEON)
1423 
1424  /* set audio service type based on bitstream mode for AC-3 */
1425  avctx->audio_service_type = s->bitstream_mode;
1426  if (s->bitstream_mode == 0x7 && s->channels > 1)
1428 
1429  /* get output buffer */
1430  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1431  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1432  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1433  return ret;
1434  }
1435 
1436  /* decode the audio blocks */
1437  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1438  for (ch = 0; ch < s->channels; ch++) {
1439  if (ch < s->out_channels)
1440  s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1441  else
1442  s->outptr[ch] = s->output[ch];
1443  output[ch] = s->output[ch];
1444  }
1445  for (blk = 0; blk < s->num_blocks; blk++) {
1446  if (!err && decode_audio_block(s, blk)) {
1447  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1448  err = 1;
1449  }
1450  if (err)
1451  for (ch = 0; ch < s->out_channels; ch++)
1452  memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1453  for (ch = 0; ch < s->out_channels; ch++)
1454  output[ch] = s->outptr[channel_map[ch]];
1455  for (ch = 0; ch < s->out_channels; ch++)
1456  s->outptr[ch] += AC3_BLOCK_SIZE;
1457  }
1458 
1459  /* keep last block for error concealment in next frame */
1460  for (ch = 0; ch < s->out_channels; ch++)
1461  memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1462 
1463  /*
1464  * AVMatrixEncoding
1465  *
1466  * Check whether the input layout is compatible, and make sure we're not
1467  * downmixing (else the matrix encoding is no longer applicable).
1468  */
1469  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1470  if (s->channel_mode == AC3_CHMODE_STEREO &&
1471  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1473  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1475  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1476  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1477  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1478  switch (s->dolby_surround_ex_mode) {
1479  case AC3_DSUREXMOD_ON: // EX or PLIIx
1480  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1481  break;
1482  case AC3_DSUREXMOD_PLIIZ:
1483  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1484  break;
1485  default: // not indicated or off
1486  break;
1487  }
1488  }
1489  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1490  return ret;
1491 
1492  /* AVDownmixInfo */
1493  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1494  switch (s->preferred_downmix) {
1495  case AC3_DMIXMOD_LTRT:
1497  break;
1498  case AC3_DMIXMOD_LORO:
1500  break;
1501  case AC3_DMIXMOD_DPLII:
1503  break;
1504  default:
1506  break;
1507  }
1508  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1509  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1510  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1512  if (s->lfe_mix_level_exists)
1513  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1514  else
1515  downmix_info->lfe_mix_level = 0.0; // -inf dB
1516  } else
1517  return AVERROR(ENOMEM);
1518 
1519  *got_frame_ptr = 1;
1520 
1521  return FFMIN(buf_size, s->frame_size);
1522 }
1523 
1528 {
1529  AC3DecodeContext *s = avctx->priv_data;
1530  ff_mdct_end(&s->imdct_512);
1531  ff_mdct_end(&s->imdct_256);
1532 
1533  return 0;
1534 }
1535 
1536 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1537 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1538 static const AVOption options[] = {
1539  { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1540  { NULL},
1541 };
1542 
1543 static const AVClass ac3_decoder_class = {
1544  .class_name = "AC3 decoder",
1545  .item_name = av_default_item_name,
1546  .option = options,
1547  .version = LIBAVUTIL_VERSION_INT,
1548 };
1549 
1551  .name = "ac3",
1552  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1553  .type = AVMEDIA_TYPE_AUDIO,
1554  .id = AV_CODEC_ID_AC3,
1555  .priv_data_size = sizeof (AC3DecodeContext),
1556  .init = ac3_decode_init,
1557  .close = ac3_decode_end,
1559  .capabilities = CODEC_CAP_DR1,
1560  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1562  .priv_class = &ac3_decoder_class,
1563 };
1564 
1565 #if CONFIG_EAC3_DECODER
1566 static const AVClass eac3_decoder_class = {
1567  .class_name = "E-AC3 decoder",
1568  .item_name = av_default_item_name,
1569  .option = options,
1570  .version = LIBAVUTIL_VERSION_INT,
1571 };
1572 
1573 AVCodec ff_eac3_decoder = {
1574  .name = "eac3",
1575  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1576  .type = AVMEDIA_TYPE_AUDIO,
1577  .id = AV_CODEC_ID_EAC3,
1578  .priv_data_size = sizeof (AC3DecodeContext),
1579  .init = ac3_decode_init,
1580  .close = ac3_decode_end,
1582  .capabilities = CODEC_CAP_DR1,
1583  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1585  .priv_class = &eac3_decoder_class,
1586 };
1587 #endif