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