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 
32 #include "libavutil/crc.h"
33 #include "libavutil/opt.h"
34 #include "internal.h"
35 #include "aac_ac3_parser.h"
36 #include "ac3_parser.h"
37 #include "ac3dec.h"
38 #include "ac3dec_data.h"
39 #include "kbdwin.h"
40 
46 
48 static int b1_mantissas[32][3];
49 static int b2_mantissas[128][3];
50 static int b3_mantissas[8];
51 static int b4_mantissas[128][2];
52 static int b5_mantissas[16];
53 
58 static const uint8_t quantization_tab[16] = {
59  0, 3, 5, 7, 11, 15,
60  5, 6, 7, 8, 9, 10, 11, 12, 14, 16
61 };
62 
64 static float dynamic_range_tab[256];
65 
67 static const float gain_levels[9] = {
70  LEVEL_ONE,
75  LEVEL_ZERO,
77 };
78 
83 static const uint8_t ac3_default_coeffs[8][5][2] = {
84  { { 2, 7 }, { 7, 2 }, },
85  { { 4, 4 }, },
86  { { 2, 7 }, { 7, 2 }, },
87  { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
88  { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
89  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
90  { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
91  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
92 };
93 
99 static inline int
100 symmetric_dequant(int code, int levels)
101 {
102  return ((code - (levels >> 1)) << 24) / levels;
103 }
104 
105 /*
106  * Initialize tables at runtime.
107  */
108 static av_cold void ac3_tables_init(void)
109 {
110  int i;
111 
112  /* generate table for ungrouping 3 values in 7 bits
113  reference: Section 7.1.3 Exponent Decoding */
114  for (i = 0; i < 128; i++) {
115  ungroup_3_in_7_bits_tab[i][0] = i / 25;
116  ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
117  ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
118  }
119 
120  /* generate grouped mantissa tables
121  reference: Section 7.3.5 Ungrouping of Mantissas */
122  for (i = 0; i < 32; i++) {
123  /* bap=1 mantissas */
127  }
128  for (i = 0; i < 128; i++) {
129  /* bap=2 mantissas */
133 
134  /* bap=4 mantissas */
135  b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
136  b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
137  }
138  /* generate ungrouped mantissa tables
139  reference: Tables 7.21 and 7.23 */
140  for (i = 0; i < 7; i++) {
141  /* bap=3 mantissas */
142  b3_mantissas[i] = symmetric_dequant(i, 7);
143  }
144  for (i = 0; i < 15; i++) {
145  /* bap=5 mantissas */
146  b5_mantissas[i] = symmetric_dequant(i, 15);
147  }
148 
149  /* generate dynamic range table
150  reference: Section 7.7.1 Dynamic Range Control */
151  for (i = 0; i < 256; i++) {
152  int v = (i >> 5) - ((i >> 7) << 3) - 5;
153  dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
154  }
155 }
156 
161 {
162  AC3DecodeContext *s = avctx->priv_data;
163  int i;
164 
165  s->avctx = avctx;
166 
168  ac3_tables_init();
169  ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
170  ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
171  ff_kbd_window_init(s->window, 5.0, 256);
172  ff_dsputil_init(&s->dsp, avctx);
175  ff_fmt_convert_init(&s->fmt_conv, avctx);
176  av_lfg_init(&s->dith_state, 0);
177 
179 
180  /* allow downmixing to stereo or mono */
181  if (avctx->channels > 0 && avctx->request_channels > 0 &&
182  avctx->request_channels < avctx->channels &&
183  avctx->request_channels <= 2) {
184  avctx->channels = avctx->request_channels;
185  }
186  s->downmixed = 1;
187 
189  avctx->coded_frame = &s->frame;
190 
191  for (i = 0; i < AC3_MAX_CHANNELS; i++) {
192  s->xcfptr[i] = s->transform_coeffs[i];
193  s->dlyptr[i] = s->delay[i];
194  }
195 
196  return 0;
197 }
198 
205 {
206  GetBitContext *gbc = &s->gbc;
207  int i;
208 
209  /* read the rest of the bsi. read twice for dual mono mode. */
210  i = !s->channel_mode;
211  do {
212  skip_bits(gbc, 5); // skip dialog normalization
213  if (get_bits1(gbc))
214  skip_bits(gbc, 8); //skip compression
215  if (get_bits1(gbc))
216  skip_bits(gbc, 8); //skip language code
217  if (get_bits1(gbc))
218  skip_bits(gbc, 7); //skip audio production information
219  } while (i--);
220 
221  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
222 
223  /* skip the timecodes (or extra bitstream information for Alternate Syntax)
224  TODO: read & use the xbsi1 downmix levels */
225  if (get_bits1(gbc))
226  skip_bits(gbc, 14); //skip timecode1 / xbsi1
227  if (get_bits1(gbc))
228  skip_bits(gbc, 14); //skip timecode2 / xbsi2
229 
230  /* skip additional bitstream info */
231  if (get_bits1(gbc)) {
232  i = get_bits(gbc, 6);
233  do {
234  skip_bits(gbc, 8);
235  } while (i--);
236  }
237 
238  return 0;
239 }
240 
245 {
246  AC3HeaderInfo hdr;
247  int err;
248 
249  err = avpriv_ac3_parse_header(&s->gbc, &hdr);
250  if (err)
251  return err;
252 
253  /* get decoding parameters from header info */
256  s->channel_mode = hdr.channel_mode;
258  s->lfe_on = hdr.lfe_on;
260  s->sample_rate = hdr.sample_rate;
261  s->bit_rate = hdr.bit_rate;
262  s->channels = hdr.channels;
263  s->fbw_channels = s->channels - s->lfe_on;
264  s->lfe_ch = s->fbw_channels + 1;
265  s->frame_size = hdr.frame_size;
268  s->num_blocks = hdr.num_blocks;
269  s->frame_type = hdr.frame_type;
270  s->substreamid = hdr.substreamid;
271 
272  if (s->lfe_on) {
273  s->start_freq[s->lfe_ch] = 0;
274  s->end_freq[s->lfe_ch] = 7;
275  s->num_exp_groups[s->lfe_ch] = 2;
276  s->channel_in_cpl[s->lfe_ch] = 0;
277  }
278 
279  if (hdr.bitstream_id <= 10) {
280  s->eac3 = 0;
281  s->snr_offset_strategy = 2;
282  s->block_switch_syntax = 1;
283  s->dither_flag_syntax = 1;
284  s->bit_allocation_syntax = 1;
285  s->fast_gain_syntax = 0;
286  s->first_cpl_leak = 0;
287  s->dba_syntax = 1;
288  s->skip_syntax = 1;
289  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
290  return ac3_parse_header(s);
291  } else if (CONFIG_EAC3_DECODER) {
292  s->eac3 = 1;
293  return ff_eac3_parse_header(s);
294  } else {
295  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
296  return AVERROR(ENOSYS);
297  }
298 }
299 
305 {
306  int i;
307  float cmix = gain_levels[s-> center_mix_level];
308  float smix = gain_levels[s->surround_mix_level];
309  float norm0, norm1;
310 
311  for (i = 0; i < s->fbw_channels; i++) {
313  s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
314  }
315  if (s->channel_mode > 1 && s->channel_mode & 1) {
316  s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
317  }
319  int nf = s->channel_mode - 2;
320  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
321  }
323  int nf = s->channel_mode - 4;
324  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
325  }
326 
327  /* renormalize */
328  norm0 = norm1 = 0.0;
329  for (i = 0; i < s->fbw_channels; i++) {
330  norm0 += s->downmix_coeffs[i][0];
331  norm1 += s->downmix_coeffs[i][1];
332  }
333  norm0 = 1.0f / norm0;
334  norm1 = 1.0f / norm1;
335  for (i = 0; i < s->fbw_channels; i++) {
336  s->downmix_coeffs[i][0] *= norm0;
337  s->downmix_coeffs[i][1] *= norm1;
338  }
339 
340  if (s->output_mode == AC3_CHMODE_MONO) {
341  for (i = 0; i < s->fbw_channels; i++)
342  s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
343  s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
344  }
345 }
346 
351 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
352  uint8_t absexp, int8_t *dexps)
353 {
354  int i, j, grp, group_size;
355  int dexp[256];
356  int expacc, prevexp;
357 
358  /* unpack groups */
359  group_size = exp_strategy + (exp_strategy == EXP_D45);
360  for (grp = 0, i = 0; grp < ngrps; grp++) {
361  expacc = get_bits(gbc, 7);
362  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
363  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
364  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
365  }
366 
367  /* convert to absolute exps and expand groups */
368  prevexp = absexp;
369  for (i = 0, j = 0; i < ngrps * 3; i++) {
370  prevexp += dexp[i] - 2;
371  if (prevexp > 24U)
372  return -1;
373  switch (group_size) {
374  case 4: dexps[j++] = prevexp;
375  dexps[j++] = prevexp;
376  case 2: dexps[j++] = prevexp;
377  case 1: dexps[j++] = prevexp;
378  }
379  }
380  return 0;
381 }
382 
389 {
390  int bin, band, ch;
391 
392  bin = s->start_freq[CPL_CH];
393  for (band = 0; band < s->num_cpl_bands; band++) {
394  int band_start = bin;
395  int band_end = bin + s->cpl_band_sizes[band];
396  for (ch = 1; ch <= s->fbw_channels; ch++) {
397  if (s->channel_in_cpl[ch]) {
398  int cpl_coord = s->cpl_coords[ch][band] << 5;
399  for (bin = band_start; bin < band_end; bin++) {
400  s->fixed_coeffs[ch][bin] =
401  MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
402  }
403  if (ch == 2 && s->phase_flags[band]) {
404  for (bin = band_start; bin < band_end; bin++)
405  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
406  }
407  }
408  }
409  bin = band_end;
410  }
411 }
412 
416 typedef struct {
417  int b1_mant[2];
418  int b2_mant[2];
419  int b4_mant;
420  int b1;
421  int b2;
422  int b4;
423 } mant_groups;
424 
430 {
431  int start_freq = s->start_freq[ch_index];
432  int end_freq = s->end_freq[ch_index];
433  uint8_t *baps = s->bap[ch_index];
434  int8_t *exps = s->dexps[ch_index];
435  int *coeffs = s->fixed_coeffs[ch_index];
436  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
437  GetBitContext *gbc = &s->gbc;
438  int freq;
439 
440  for (freq = start_freq; freq < end_freq; freq++) {
441  int bap = baps[freq];
442  int mantissa;
443  switch (bap) {
444  case 0:
445  if (dither)
446  mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
447  else
448  mantissa = 0;
449  break;
450  case 1:
451  if (m->b1) {
452  m->b1--;
453  mantissa = m->b1_mant[m->b1];
454  } else {
455  int bits = get_bits(gbc, 5);
456  mantissa = b1_mantissas[bits][0];
457  m->b1_mant[1] = b1_mantissas[bits][1];
458  m->b1_mant[0] = b1_mantissas[bits][2];
459  m->b1 = 2;
460  }
461  break;
462  case 2:
463  if (m->b2) {
464  m->b2--;
465  mantissa = m->b2_mant[m->b2];
466  } else {
467  int bits = get_bits(gbc, 7);
468  mantissa = b2_mantissas[bits][0];
469  m->b2_mant[1] = b2_mantissas[bits][1];
470  m->b2_mant[0] = b2_mantissas[bits][2];
471  m->b2 = 2;
472  }
473  break;
474  case 3:
475  mantissa = b3_mantissas[get_bits(gbc, 3)];
476  break;
477  case 4:
478  if (m->b4) {
479  m->b4 = 0;
480  mantissa = m->b4_mant;
481  } else {
482  int bits = get_bits(gbc, 7);
483  mantissa = b4_mantissas[bits][0];
484  m->b4_mant = b4_mantissas[bits][1];
485  m->b4 = 1;
486  }
487  break;
488  case 5:
489  mantissa = b5_mantissas[get_bits(gbc, 4)];
490  break;
491  default: /* 6 to 15 */
492  /* Shift mantissa and sign-extend it. */
493  mantissa = get_sbits(gbc, quantization_tab[bap]);
494  mantissa <<= 24 - quantization_tab[bap];
495  break;
496  }
497  coeffs[freq] = mantissa >> exps[freq];
498  }
499 }
500 
507  int ch, i;
508 
509  for (ch = 1; ch <= s->fbw_channels; ch++) {
510  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
511  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
512  if (!s->bap[CPL_CH][i])
513  s->fixed_coeffs[ch][i] = 0;
514  }
515  }
516  }
517 }
518 
519 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
520  mant_groups *m)
521 {
522  if (!s->channel_uses_aht[ch]) {
524  } else {
525  /* if AHT is used, mantissas for all blocks are encoded in the first
526  block of the frame. */
527  int bin;
528  if (!blk && CONFIG_EAC3_DECODER)
530  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
531  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
532  }
533  }
534 }
535 
540 {
541  int ch, end;
542  int got_cplchan = 0;
543  mant_groups m;
544 
545  m.b1 = m.b2 = m.b4 = 0;
546 
547  for (ch = 1; ch <= s->channels; ch++) {
548  /* transform coefficients for full-bandwidth channel */
549  decode_transform_coeffs_ch(s, blk, ch, &m);
550  /* transform coefficients for coupling channel come right after the
551  coefficients for the first coupled channel*/
552  if (s->channel_in_cpl[ch]) {
553  if (!got_cplchan) {
554  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
556  got_cplchan = 1;
557  }
558  end = s->end_freq[CPL_CH];
559  } else {
560  end = s->end_freq[ch];
561  }
562  do
563  s->fixed_coeffs[ch][end] = 0;
564  while (++end < 256);
565  }
566 
567  /* zero the dithered coefficients for appropriate channels */
568  remove_dithering(s);
569 }
570 
576 {
577  int bnd, i;
578  int end, bndend;
579 
580  end = FFMIN(s->end_freq[1], s->end_freq[2]);
581 
582  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
583  if (s->rematrixing_flags[bnd]) {
584  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
585  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
586  int tmp0 = s->fixed_coeffs[1][i];
587  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
588  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
589  }
590  }
591  }
592 }
593 
599 static inline void do_imdct(AC3DecodeContext *s, int channels)
600 {
601  int ch;
602 
603  for (ch = 1; ch <= channels; ch++) {
604  if (s->block_switch[ch]) {
605  int i;
606  float *x = s->tmp_output + 128;
607  for (i = 0; i < 128; i++)
608  x[i] = s->transform_coeffs[ch][2 * i];
609  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
610  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
611  s->tmp_output, s->window, 128);
612  for (i = 0; i < 128; i++)
613  x[i] = s->transform_coeffs[ch][2 * i + 1];
614  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
615  } else {
617  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
618  s->tmp_output, s->window, 128);
619  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
620  }
621  }
622 }
623 
628 {
629  int channel_data_size = sizeof(s->delay[0]);
630  switch (s->channel_mode) {
631  case AC3_CHMODE_DUALMONO:
632  case AC3_CHMODE_STEREO:
633  /* upmix mono to stereo */
634  memcpy(s->delay[1], s->delay[0], channel_data_size);
635  break;
636  case AC3_CHMODE_2F2R:
637  memset(s->delay[3], 0, channel_data_size);
638  case AC3_CHMODE_2F1R:
639  memset(s->delay[2], 0, channel_data_size);
640  break;
641  case AC3_CHMODE_3F2R:
642  memset(s->delay[4], 0, channel_data_size);
643  case AC3_CHMODE_3F1R:
644  memset(s->delay[3], 0, channel_data_size);
645  case AC3_CHMODE_3F:
646  memcpy(s->delay[2], s->delay[1], channel_data_size);
647  memset(s->delay[1], 0, channel_data_size);
648  break;
649  }
650 }
651 
668 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
669  int ecpl, int start_subband, int end_subband,
670  const uint8_t *default_band_struct,
671  int *num_bands, uint8_t *band_sizes)
672 {
673  int subbnd, bnd, n_subbands, n_bands=0;
674  uint8_t bnd_sz[22];
675  uint8_t coded_band_struct[22];
676  const uint8_t *band_struct;
677 
678  n_subbands = end_subband - start_subband;
679 
680  /* decode band structure from bitstream or use default */
681  if (!eac3 || get_bits1(gbc)) {
682  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
683  coded_band_struct[subbnd] = get_bits1(gbc);
684  }
685  band_struct = coded_band_struct;
686  } else if (!blk) {
687  band_struct = &default_band_struct[start_subband+1];
688  } else {
689  /* no change in band structure */
690  return;
691  }
692 
693  /* calculate number of bands and band sizes based on band structure.
694  note that the first 4 subbands in enhanced coupling span only 6 bins
695  instead of 12. */
696  if (num_bands || band_sizes ) {
697  n_bands = n_subbands;
698  bnd_sz[0] = ecpl ? 6 : 12;
699  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
700  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
701  if (band_struct[subbnd - 1]) {
702  n_bands--;
703  bnd_sz[bnd] += subbnd_size;
704  } else {
705  bnd_sz[++bnd] = subbnd_size;
706  }
707  }
708  }
709 
710  /* set optional output params */
711  if (num_bands)
712  *num_bands = n_bands;
713  if (band_sizes)
714  memcpy(band_sizes, bnd_sz, n_bands);
715 }
716 
721 {
722  int fbw_channels = s->fbw_channels;
723  int channel_mode = s->channel_mode;
724  int i, bnd, seg, ch;
725  int different_transforms;
726  int downmix_output;
727  int cpl_in_use;
728  GetBitContext *gbc = &s->gbc;
729  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
730 
731  /* block switch flags */
732  different_transforms = 0;
733  if (s->block_switch_syntax) {
734  for (ch = 1; ch <= fbw_channels; ch++) {
735  s->block_switch[ch] = get_bits1(gbc);
736  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
737  different_transforms = 1;
738  }
739  }
740 
741  /* dithering flags */
742  if (s->dither_flag_syntax) {
743  for (ch = 1; ch <= fbw_channels; ch++) {
744  s->dither_flag[ch] = get_bits1(gbc);
745  }
746  }
747 
748  /* dynamic range */
749  i = !s->channel_mode;
750  do {
751  if (get_bits1(gbc)) {
752  s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
753  s->drc_scale) + 1.0;
754  } else if (blk == 0) {
755  s->dynamic_range[i] = 1.0f;
756  }
757  } while (i--);
758 
759  /* spectral extension strategy */
760  if (s->eac3 && (!blk || get_bits1(gbc))) {
761  s->spx_in_use = get_bits1(gbc);
762  if (s->spx_in_use) {
763  int dst_start_freq, dst_end_freq, src_start_freq,
764  start_subband, end_subband;
765 
766  /* determine which channels use spx */
767  if (s->channel_mode == AC3_CHMODE_MONO) {
768  s->channel_uses_spx[1] = 1;
769  } else {
770  for (ch = 1; ch <= fbw_channels; ch++)
771  s->channel_uses_spx[ch] = get_bits1(gbc);
772  }
773 
774  /* get the frequency bins of the spx copy region and the spx start
775  and end subbands */
776  dst_start_freq = get_bits(gbc, 2);
777  start_subband = get_bits(gbc, 3) + 2;
778  if (start_subband > 7)
779  start_subband += start_subband - 7;
780  end_subband = get_bits(gbc, 3) + 5;
781  if (end_subband > 7)
782  end_subband += end_subband - 7;
783  dst_start_freq = dst_start_freq * 12 + 25;
784  src_start_freq = start_subband * 12 + 25;
785  dst_end_freq = end_subband * 12 + 25;
786 
787  /* check validity of spx ranges */
788  if (start_subband >= end_subband) {
789  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
790  "range (%d >= %d)\n", start_subband, end_subband);
791  return AVERROR_INVALIDDATA;
792  }
793  if (dst_start_freq >= src_start_freq) {
794  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
795  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
796  return AVERROR_INVALIDDATA;
797  }
798 
799  s->spx_dst_start_freq = dst_start_freq;
800  s->spx_src_start_freq = src_start_freq;
801  s->spx_dst_end_freq = dst_end_freq;
802 
803  decode_band_structure(gbc, blk, s->eac3, 0,
804  start_subband, end_subband,
806  &s->num_spx_bands,
807  s->spx_band_sizes);
808  } else {
809  for (ch = 1; ch <= fbw_channels; ch++) {
810  s->channel_uses_spx[ch] = 0;
811  s->first_spx_coords[ch] = 1;
812  }
813  }
814  }
815 
816  /* spectral extension coordinates */
817  if (s->spx_in_use) {
818  for (ch = 1; ch <= fbw_channels; ch++) {
819  if (s->channel_uses_spx[ch]) {
820  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
821  float spx_blend;
822  int bin, master_spx_coord;
823 
824  s->first_spx_coords[ch] = 0;
825  spx_blend = get_bits(gbc, 5) * (1.0f/32);
826  master_spx_coord = get_bits(gbc, 2) * 3;
827 
828  bin = s->spx_src_start_freq;
829  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
830  int bandsize;
831  int spx_coord_exp, spx_coord_mant;
832  float nratio, sblend, nblend, spx_coord;
833 
834  /* calculate blending factors */
835  bandsize = s->spx_band_sizes[bnd];
836  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
837  nratio = av_clipf(nratio, 0.0f, 1.0f);
838  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
839  // to give unity variance
840  sblend = sqrtf(1.0f - nratio);
841  bin += bandsize;
842 
843  /* decode spx coordinates */
844  spx_coord_exp = get_bits(gbc, 4);
845  spx_coord_mant = get_bits(gbc, 2);
846  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
847  else spx_coord_mant += 4;
848  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
849  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
850 
851  /* multiply noise and signal blending factors by spx coordinate */
852  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
853  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
854  }
855  }
856  } else {
857  s->first_spx_coords[ch] = 1;
858  }
859  }
860  }
861 
862  /* coupling strategy */
863  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
864  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
865  if (!s->eac3)
866  s->cpl_in_use[blk] = get_bits1(gbc);
867  if (s->cpl_in_use[blk]) {
868  /* coupling in use */
869  int cpl_start_subband, cpl_end_subband;
870 
871  if (channel_mode < AC3_CHMODE_STEREO) {
872  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
873  return AVERROR_INVALIDDATA;
874  }
875 
876  /* check for enhanced coupling */
877  if (s->eac3 && get_bits1(gbc)) {
878  /* TODO: parse enhanced coupling strategy info */
879  av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
880  return AVERROR_PATCHWELCOME;
881  }
882 
883  /* determine which channels are coupled */
884  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
885  s->channel_in_cpl[1] = 1;
886  s->channel_in_cpl[2] = 1;
887  } else {
888  for (ch = 1; ch <= fbw_channels; ch++)
889  s->channel_in_cpl[ch] = get_bits1(gbc);
890  }
891 
892  /* phase flags in use */
893  if (channel_mode == AC3_CHMODE_STEREO)
894  s->phase_flags_in_use = get_bits1(gbc);
895 
896  /* coupling frequency range */
897  cpl_start_subband = get_bits(gbc, 4);
898  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
899  get_bits(gbc, 4) + 3;
900  if (cpl_start_subband >= cpl_end_subband) {
901  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
902  cpl_start_subband, cpl_end_subband);
903  return AVERROR_INVALIDDATA;
904  }
905  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
906  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
907 
908  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
909  cpl_end_subband,
911  &s->num_cpl_bands, s->cpl_band_sizes);
912  } else {
913  /* coupling not in use */
914  for (ch = 1; ch <= fbw_channels; ch++) {
915  s->channel_in_cpl[ch] = 0;
916  s->first_cpl_coords[ch] = 1;
917  }
918  s->first_cpl_leak = s->eac3;
919  s->phase_flags_in_use = 0;
920  }
921  } else if (!s->eac3) {
922  if (!blk) {
923  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
924  "be present in block 0\n");
925  return AVERROR_INVALIDDATA;
926  } else {
927  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
928  }
929  }
930  cpl_in_use = s->cpl_in_use[blk];
931 
932  /* coupling coordinates */
933  if (cpl_in_use) {
934  int cpl_coords_exist = 0;
935 
936  for (ch = 1; ch <= fbw_channels; ch++) {
937  if (s->channel_in_cpl[ch]) {
938  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
939  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
940  s->first_cpl_coords[ch] = 0;
941  cpl_coords_exist = 1;
942  master_cpl_coord = 3 * get_bits(gbc, 2);
943  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
944  cpl_coord_exp = get_bits(gbc, 4);
945  cpl_coord_mant = get_bits(gbc, 4);
946  if (cpl_coord_exp == 15)
947  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
948  else
949  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
950  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
951  }
952  } else if (!blk) {
953  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
954  "be present in block 0\n");
955  return AVERROR_INVALIDDATA;
956  }
957  } else {
958  /* channel not in coupling */
959  s->first_cpl_coords[ch] = 1;
960  }
961  }
962  /* phase flags */
963  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
964  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
965  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
966  }
967  }
968  }
969 
970  /* stereo rematrixing strategy and band structure */
971  if (channel_mode == AC3_CHMODE_STEREO) {
972  if ((s->eac3 && !blk) || get_bits1(gbc)) {
973  s->num_rematrixing_bands = 4;
974  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
975  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
976  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
978  }
979  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
980  s->rematrixing_flags[bnd] = get_bits1(gbc);
981  } else if (!blk) {
982  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
983  "new rematrixing strategy not present in block 0\n");
984  s->num_rematrixing_bands = 0;
985  }
986  }
987 
988  /* exponent strategies for each channel */
989  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
990  if (!s->eac3)
991  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
992  if (s->exp_strategy[blk][ch] != EXP_REUSE)
993  bit_alloc_stages[ch] = 3;
994  }
995 
996  /* channel bandwidth */
997  for (ch = 1; ch <= fbw_channels; ch++) {
998  s->start_freq[ch] = 0;
999  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1000  int group_size;
1001  int prev = s->end_freq[ch];
1002  if (s->channel_in_cpl[ch])
1003  s->end_freq[ch] = s->start_freq[CPL_CH];
1004  else if (s->channel_uses_spx[ch])
1005  s->end_freq[ch] = s->spx_src_start_freq;
1006  else {
1007  int bandwidth_code = get_bits(gbc, 6);
1008  if (bandwidth_code > 60) {
1009  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1010  return AVERROR_INVALIDDATA;
1011  }
1012  s->end_freq[ch] = bandwidth_code * 3 + 73;
1013  }
1014  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1015  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1016  if (blk > 0 && s->end_freq[ch] != prev)
1017  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1018  }
1019  }
1020  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1022  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1023  }
1024 
1025  /* decode exponents for each channel */
1026  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1027  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1028  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1029  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1030  s->num_exp_groups[ch], s->dexps[ch][0],
1031  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1032  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1033  return AVERROR_INVALIDDATA;
1034  }
1035  if (ch != CPL_CH && ch != s->lfe_ch)
1036  skip_bits(gbc, 2); /* skip gainrng */
1037  }
1038  }
1039 
1040  /* bit allocation information */
1041  if (s->bit_allocation_syntax) {
1042  if (get_bits1(gbc)) {
1048  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1049  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1050  } else if (!blk) {
1051  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1052  "be present in block 0\n");
1053  return AVERROR_INVALIDDATA;
1054  }
1055  }
1056 
1057  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1058  if (!s->eac3 || !blk) {
1059  if (s->snr_offset_strategy && get_bits1(gbc)) {
1060  int snr = 0;
1061  int csnr;
1062  csnr = (get_bits(gbc, 6) - 15) << 4;
1063  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1064  /* snr offset */
1065  if (ch == i || s->snr_offset_strategy == 2)
1066  snr = (csnr + get_bits(gbc, 4)) << 2;
1067  /* run at least last bit allocation stage if snr offset changes */
1068  if (blk && s->snr_offset[ch] != snr) {
1069  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1070  }
1071  s->snr_offset[ch] = snr;
1072 
1073  /* fast gain (normal AC-3 only) */
1074  if (!s->eac3) {
1075  int prev = s->fast_gain[ch];
1076  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1077  /* run last 2 bit allocation stages if fast gain changes */
1078  if (blk && prev != s->fast_gain[ch])
1079  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1080  }
1081  }
1082  } else if (!s->eac3 && !blk) {
1083  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1084  return AVERROR_INVALIDDATA;
1085  }
1086  }
1087 
1088  /* fast gain (E-AC-3 only) */
1089  if (s->fast_gain_syntax && get_bits1(gbc)) {
1090  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1091  int prev = s->fast_gain[ch];
1092  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1093  /* run last 2 bit allocation stages if fast gain changes */
1094  if (blk && prev != s->fast_gain[ch])
1095  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1096  }
1097  } else if (s->eac3 && !blk) {
1098  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1099  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1100  }
1101 
1102  /* E-AC-3 to AC-3 converter SNR offset */
1103  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1104  skip_bits(gbc, 10); // skip converter snr offset
1105  }
1106 
1107  /* coupling leak information */
1108  if (cpl_in_use) {
1109  if (s->first_cpl_leak || get_bits1(gbc)) {
1110  int fl = get_bits(gbc, 3);
1111  int sl = get_bits(gbc, 3);
1112  /* run last 2 bit allocation stages for coupling channel if
1113  coupling leak changes */
1114  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1115  sl != s->bit_alloc_params.cpl_slow_leak)) {
1116  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1117  }
1120  } else if (!s->eac3 && !blk) {
1121  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1122  "be present in block 0\n");
1123  return AVERROR_INVALIDDATA;
1124  }
1125  s->first_cpl_leak = 0;
1126  }
1127 
1128  /* delta bit allocation information */
1129  if (s->dba_syntax && get_bits1(gbc)) {
1130  /* delta bit allocation exists (strategy) */
1131  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1132  s->dba_mode[ch] = get_bits(gbc, 2);
1133  if (s->dba_mode[ch] == DBA_RESERVED) {
1134  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1135  return AVERROR_INVALIDDATA;
1136  }
1137  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1138  }
1139  /* channel delta offset, len and bit allocation */
1140  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1141  if (s->dba_mode[ch] == DBA_NEW) {
1142  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1143  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1144  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1145  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1146  s->dba_values[ch][seg] = get_bits(gbc, 3);
1147  }
1148  /* run last 2 bit allocation stages if new dba values */
1149  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1150  }
1151  }
1152  } else if (blk == 0) {
1153  for (ch = 0; ch <= s->channels; ch++) {
1154  s->dba_mode[ch] = DBA_NONE;
1155  }
1156  }
1157 
1158  /* Bit allocation */
1159  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1160  if (bit_alloc_stages[ch] > 2) {
1161  /* Exponent mapping into PSD and PSD integration */
1163  s->start_freq[ch], s->end_freq[ch],
1164  s->psd[ch], s->band_psd[ch]);
1165  }
1166  if (bit_alloc_stages[ch] > 1) {
1167  /* Compute excitation function, Compute masking curve, and
1168  Apply delta bit allocation */
1170  s->start_freq[ch], s->end_freq[ch],
1171  s->fast_gain[ch], (ch == s->lfe_ch),
1172  s->dba_mode[ch], s->dba_nsegs[ch],
1173  s->dba_offsets[ch], s->dba_lengths[ch],
1174  s->dba_values[ch], s->mask[ch])) {
1175  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1176  return AVERROR_INVALIDDATA;
1177  }
1178  }
1179  if (bit_alloc_stages[ch] > 0) {
1180  /* Compute bit allocation */
1181  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1183  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1184  s->start_freq[ch], s->end_freq[ch],
1185  s->snr_offset[ch],
1187  bap_tab, s->bap[ch]);
1188  }
1189  }
1190 
1191  /* unused dummy data */
1192  if (s->skip_syntax && get_bits1(gbc)) {
1193  int skipl = get_bits(gbc, 9);
1194  while (skipl--)
1195  skip_bits(gbc, 8);
1196  }
1197 
1198  /* unpack the transform coefficients
1199  this also uncouples channels if coupling is in use. */
1200  decode_transform_coeffs(s, blk);
1201 
1202  /* TODO: generate enhanced coupling coordinates and uncouple */
1203 
1204  /* recover coefficients if rematrixing is in use */
1205  if (s->channel_mode == AC3_CHMODE_STEREO)
1206  do_rematrixing(s);
1207 
1208  /* apply scaling to coefficients (headroom, dynrng) */
1209  for (ch = 1; ch <= s->channels; ch++) {
1210  float gain = 1.0 / 4194304.0f;
1211  if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1212  gain *= s->dynamic_range[2 - ch];
1213  } else {
1214  gain *= s->dynamic_range[0];
1215  }
1217  s->fixed_coeffs[ch], gain, 256);
1218  }
1219 
1220  /* apply spectral extension to high frequency bins */
1221  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1223  }
1224 
1225  /* downmix and MDCT. order depends on whether block switching is used for
1226  any channel in this block. this is because coefficients for the long
1227  and short transforms cannot be mixed. */
1228  downmix_output = s->channels != s->out_channels &&
1229  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1230  s->fbw_channels == s->out_channels);
1231  if (different_transforms) {
1232  /* the delay samples have already been downmixed, so we upmix the delay
1233  samples in order to reconstruct all channels before downmixing. */
1234  if (s->downmixed) {
1235  s->downmixed = 0;
1236  ac3_upmix_delay(s);
1237  }
1238 
1239  do_imdct(s, s->channels);
1240 
1241  if (downmix_output) {
1242  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1243  s->out_channels, s->fbw_channels, 256);
1244  }
1245  } else {
1246  if (downmix_output) {
1247  s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1248  s->out_channels, s->fbw_channels, 256);
1249  }
1250 
1251  if (downmix_output && !s->downmixed) {
1252  s->downmixed = 1;
1254  s->fbw_channels, 128);
1255  }
1256 
1257  do_imdct(s, s->out_channels);
1258  }
1259 
1260  return 0;
1261 }
1262 
1266 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1267  int *got_frame_ptr, AVPacket *avpkt)
1268 {
1269  const uint8_t *buf = avpkt->data;
1270  int buf_size = avpkt->size;
1271  AC3DecodeContext *s = avctx->priv_data;
1272  int blk, ch, err, ret;
1273  const uint8_t *channel_map;
1274  const float *output[AC3_MAX_CHANNELS];
1275 
1276  /* copy input buffer to decoder context to avoid reading past the end
1277  of the buffer, which can be caused by a damaged input stream. */
1278  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1279  // seems to be byte-swapped AC-3
1280  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1281  s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1282  } else
1283  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1284  buf = s->input_buffer;
1285  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1286  init_get_bits(&s->gbc, buf, buf_size * 8);
1287 
1288  /* parse the syncinfo */
1289  err = parse_frame_header(s);
1290 
1291  if (err) {
1292  switch (err) {
1294  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1295  return AVERROR_INVALIDDATA;
1297  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1298  break;
1300  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1301  break;
1303  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1304  break;
1306  /* skip frame if CRC is ok. otherwise use error concealment. */
1307  /* TODO: add support for substreams and dependent frames */
1309  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1310  "skipping frame\n");
1311  *got_frame_ptr = 0;
1312  return buf_size;
1313  } else {
1314  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1315  }
1316  break;
1319  break;
1320  default: // Normal AVERROR do not try to recover.
1321  *got_frame_ptr = 0;
1322  return err;
1323  }
1324  } else {
1325  /* check that reported frame size fits in input buffer */
1326  if (s->frame_size > buf_size) {
1327  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1329  } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1330  /* check for crc mismatch */
1331  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1332  s->frame_size - 2)) {
1333  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1335  }
1336  }
1337  }
1338 
1339  /* if frame is ok, set audio parameters */
1340  if (!err) {
1341  avctx->sample_rate = s->sample_rate;
1342  avctx->bit_rate = s->bit_rate;
1343  }
1344 
1345  /* channel config */
1346  if (!err || (s->channels && s->out_channels != s->channels)) {
1347  s->out_channels = s->channels;
1348  s->output_mode = s->channel_mode;
1349  if (s->lfe_on)
1351  if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1352  avctx->request_channels < s->channels) {
1353  s->out_channels = avctx->request_channels;
1354  s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1356  }
1357  avctx->channels = s->out_channels;
1358  avctx->channel_layout = s->channel_layout;
1359 
1360  /* set downmixing coefficients if needed */
1361  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1362  s->fbw_channels == s->out_channels)) {
1363  set_downmix_coeffs(s);
1364  }
1365  } else if (!s->channels) {
1366  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1367  return AVERROR_INVALIDDATA;
1368  }
1369  avctx->channels = s->out_channels;
1370 
1371  /* set audio service type based on bitstream mode for AC-3 */
1372  avctx->audio_service_type = s->bitstream_mode;
1373  if (s->bitstream_mode == 0x7 && s->channels > 1)
1375 
1376  /* get output buffer */
1377  s->frame.nb_samples = s->num_blocks * 256;
1378  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
1379  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1380  return ret;
1381  }
1382 
1383  /* decode the audio blocks */
1384  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1385  for (ch = 0; ch < s->channels; ch++) {
1386  if (ch < s->out_channels)
1387  s->outptr[channel_map[ch]] = (float *)s->frame.data[ch];
1388  else
1389  s->outptr[ch] = s->output[ch];
1390  output[ch] = s->output[ch];
1391  }
1392  for (blk = 0; blk < s->num_blocks; blk++) {
1393  if (!err && decode_audio_block(s, blk)) {
1394  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1395  err = 1;
1396  }
1397  if (err)
1398  for (ch = 0; ch < s->out_channels; ch++)
1399  memcpy(s->outptr[channel_map[ch]], output[ch], 1024);
1400  for (ch = 0; ch < s->out_channels; ch++)
1401  output[ch] = s->outptr[channel_map[ch]];
1402  for (ch = 0; ch < s->out_channels; ch++)
1403  s->outptr[ch] += AC3_BLOCK_SIZE;
1404  }
1405 
1406  /* keep last block for error concealment in next frame */
1407  for (ch = 0; ch < s->out_channels; ch++)
1408  memcpy(s->output[ch], output[ch], 1024);
1409 
1410  *got_frame_ptr = 1;
1411  *(AVFrame *)data = s->frame;
1412 
1413  return FFMIN(buf_size, s->frame_size);
1414 }
1415 
1420 {
1421  AC3DecodeContext *s = avctx->priv_data;
1422  ff_mdct_end(&s->imdct_512);
1423  ff_mdct_end(&s->imdct_256);
1424 
1425  return 0;
1426 }
1427 
1428 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1429 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1430 static const AVOption options[] = {
1431  { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1432  { NULL},
1433 };
1434 
1435 static const AVClass ac3_decoder_class = {
1436  .class_name = "AC3 decoder",
1437  .item_name = av_default_item_name,
1438  .option = options,
1439  .version = LIBAVUTIL_VERSION_INT,
1440 };
1441 
1443  .name = "ac3",
1444  .type = AVMEDIA_TYPE_AUDIO,
1445  .id = AV_CODEC_ID_AC3,
1446  .priv_data_size = sizeof (AC3DecodeContext),
1447  .init = ac3_decode_init,
1448  .close = ac3_decode_end,
1450  .capabilities = CODEC_CAP_DR1,
1451  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1452  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1454  .priv_class = &ac3_decoder_class,
1455 };
1456 
1457 #if CONFIG_EAC3_DECODER
1458 static const AVClass eac3_decoder_class = {
1459  .class_name = "E-AC3 decoder",
1460  .item_name = av_default_item_name,
1461  .option = options,
1462  .version = LIBAVUTIL_VERSION_INT,
1463 };
1464 
1465 AVCodec ff_eac3_decoder = {
1466  .name = "eac3",
1467  .type = AVMEDIA_TYPE_AUDIO,
1468  .id = AV_CODEC_ID_EAC3,
1469  .priv_data_size = sizeof (AC3DecodeContext),
1470  .init = ac3_decode_init,
1471  .close = ac3_decode_end,
1473  .capabilities = CODEC_CAP_DR1,
1474  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1475  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1477  .priv_class = &eac3_decoder_class,
1478 };
1479 #endif