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