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 -1;
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  mantissa = get_sbits(gbc, quantization_tab[bap]);
492  mantissa <<= 24 - quantization_tab[bap];
493  break;
494  }
495  coeffs[freq] = mantissa >> exps[freq];
496  }
497 }
498 
499 /**
500  * Remove random dithering from coupling range coefficients with zero-bit
501  * mantissas for coupled channels which do not use dithering.
502  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
503  */
505  int ch, i;
506 
507  for (ch = 1; ch <= s->fbw_channels; ch++) {
508  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
509  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
510  if (!s->bap[CPL_CH][i])
511  s->fixed_coeffs[ch][i] = 0;
512  }
513  }
514  }
515 }
516 
518  mant_groups *m)
519 {
520  if (!s->channel_uses_aht[ch]) {
522  } else {
523  /* if AHT is used, mantissas for all blocks are encoded in the first
524  block of the frame. */
525  int bin;
526  if (!blk && CONFIG_EAC3_DECODER)
528  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
529  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
530  }
531  }
532 }
533 
534 /**
535  * Decode the transform coefficients.
536  */
538 {
539  int ch, end;
540  int got_cplchan = 0;
541  mant_groups m;
542 
543  m.b1 = m.b2 = m.b4 = 0;
544 
545  for (ch = 1; ch <= s->channels; ch++) {
546  /* transform coefficients for full-bandwidth channel */
547  decode_transform_coeffs_ch(s, blk, ch, &m);
548  /* transform coefficients for coupling channel come right after the
549  coefficients for the first coupled channel*/
550  if (s->channel_in_cpl[ch]) {
551  if (!got_cplchan) {
552  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
554  got_cplchan = 1;
555  }
556  end = s->end_freq[CPL_CH];
557  } else {
558  end = s->end_freq[ch];
559  }
560  do
561  s->fixed_coeffs[ch][end] = 0;
562  while (++end < 256);
563  }
564 
565  /* zero the dithered coefficients for appropriate channels */
566  remove_dithering(s);
567 }
568 
569 /**
570  * Stereo rematrixing.
571  * reference: Section 7.5.4 Rematrixing : Decoding Technique
572  */
574 {
575  int bnd, i;
576  int end, bndend;
577 
578  end = FFMIN(s->end_freq[1], s->end_freq[2]);
579 
580  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
581  if (s->rematrixing_flags[bnd]) {
582  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
583  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
584  int tmp0 = s->fixed_coeffs[1][i];
585  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
586  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
587  }
588  }
589  }
590 }
591 
592 /**
593  * Inverse MDCT Transform.
594  * Convert frequency domain coefficients to time-domain audio samples.
595  * reference: Section 7.9.4 Transformation Equations
596  */
597 static inline void do_imdct(AC3DecodeContext *s, int channels)
598 {
599  int ch;
600 
601  for (ch = 1; ch <= channels; ch++) {
602  if (s->block_switch[ch]) {
603  int i;
604  float *x = s->tmp_output + 128;
605  for (i = 0; i < 128; i++)
606  x[i] = s->transform_coeffs[ch][2 * i];
607  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
608  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
609  s->tmp_output, s->window, 128);
610  for (i = 0; i < 128; i++)
611  x[i] = s->transform_coeffs[ch][2 * i + 1];
612  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
613  } else {
615  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
616  s->tmp_output, s->window, 128);
617  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
618  }
619  }
620 }
621 
622 /**
623  * Upmix delay samples from stereo to original channel layout.
624  */
626 {
627  int channel_data_size = sizeof(s->delay[0]);
628  switch (s->channel_mode) {
629  case AC3_CHMODE_DUALMONO:
630  case AC3_CHMODE_STEREO:
631  /* upmix mono to stereo */
632  memcpy(s->delay[1], s->delay[0], channel_data_size);
633  break;
634  case AC3_CHMODE_2F2R:
635  memset(s->delay[3], 0, channel_data_size);
636  case AC3_CHMODE_2F1R:
637  memset(s->delay[2], 0, channel_data_size);
638  break;
639  case AC3_CHMODE_3F2R:
640  memset(s->delay[4], 0, channel_data_size);
641  case AC3_CHMODE_3F1R:
642  memset(s->delay[3], 0, channel_data_size);
643  case AC3_CHMODE_3F:
644  memcpy(s->delay[2], s->delay[1], channel_data_size);
645  memset(s->delay[1], 0, channel_data_size);
646  break;
647  }
648 }
649 
650 /**
651  * Decode band structure for coupling, spectral extension, or enhanced coupling.
652  * The band structure defines how many subbands are in each band. For each
653  * subband in the range, 1 means it is combined with the previous band, and 0
654  * means that it starts a new band.
655  *
656  * @param[in] gbc bit reader context
657  * @param[in] blk block number
658  * @param[in] eac3 flag to indicate E-AC-3
659  * @param[in] ecpl flag to indicate enhanced coupling
660  * @param[in] start_subband subband number for start of range
661  * @param[in] end_subband subband number for end of range
662  * @param[in] default_band_struct default band structure table
663  * @param[out] num_bands number of bands (optionally NULL)
664  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
665  */
666 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
667  int ecpl, int start_subband, int end_subband,
668  const uint8_t *default_band_struct,
669  int *num_bands, uint8_t *band_sizes)
670 {
671  int subbnd, bnd, n_subbands, n_bands=0;
672  uint8_t bnd_sz[22];
673  uint8_t coded_band_struct[22];
674  const uint8_t *band_struct;
675 
676  n_subbands = end_subband - start_subband;
677 
678  /* decode band structure from bitstream or use default */
679  if (!eac3 || get_bits1(gbc)) {
680  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
681  coded_band_struct[subbnd] = get_bits1(gbc);
682  }
683  band_struct = coded_band_struct;
684  } else if (!blk) {
685  band_struct = &default_band_struct[start_subband+1];
686  } else {
687  /* no change in band structure */
688  return;
689  }
690 
691  /* calculate number of bands and band sizes based on band structure.
692  note that the first 4 subbands in enhanced coupling span only 6 bins
693  instead of 12. */
694  if (num_bands || band_sizes ) {
695  n_bands = n_subbands;
696  bnd_sz[0] = ecpl ? 6 : 12;
697  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
698  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
699  if (band_struct[subbnd - 1]) {
700  n_bands--;
701  bnd_sz[bnd] += subbnd_size;
702  } else {
703  bnd_sz[++bnd] = subbnd_size;
704  }
705  }
706  }
707 
708  /* set optional output params */
709  if (num_bands)
710  *num_bands = n_bands;
711  if (band_sizes)
712  memcpy(band_sizes, bnd_sz, n_bands);
713 }
714 
715 /**
716  * Decode a single audio block from the AC-3 bitstream.
717  */
719 {
720  int fbw_channels = s->fbw_channels;
721  int channel_mode = s->channel_mode;
722  int i, bnd, seg, ch;
723  int different_transforms;
724  int downmix_output;
725  int cpl_in_use;
726  GetBitContext *gbc = &s->gbc;
727  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
728 
729  /* block switch flags */
730  different_transforms = 0;
731  if (s->block_switch_syntax) {
732  for (ch = 1; ch <= fbw_channels; ch++) {
733  s->block_switch[ch] = get_bits1(gbc);
734  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
735  different_transforms = 1;
736  }
737  }
738 
739  /* dithering flags */
740  if (s->dither_flag_syntax) {
741  for (ch = 1; ch <= fbw_channels; ch++) {
742  s->dither_flag[ch] = get_bits1(gbc);
743  }
744  }
745 
746  /* dynamic range */
747  i = !s->channel_mode;
748  do {
749  if (get_bits1(gbc)) {
750  s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
751  s->drc_scale) + 1.0;
752  } else if (blk == 0) {
753  s->dynamic_range[i] = 1.0f;
754  }
755  } while (i--);
756 
757  /* spectral extension strategy */
758  if (s->eac3 && (!blk || get_bits1(gbc))) {
759  s->spx_in_use = get_bits1(gbc);
760  if (s->spx_in_use) {
761  int dst_start_freq, dst_end_freq, src_start_freq,
762  start_subband, end_subband;
763 
764  /* determine which channels use spx */
765  if (s->channel_mode == AC3_CHMODE_MONO) {
766  s->channel_uses_spx[1] = 1;
767  } else {
768  for (ch = 1; ch <= fbw_channels; ch++)
769  s->channel_uses_spx[ch] = get_bits1(gbc);
770  }
771 
772  /* get the frequency bins of the spx copy region and the spx start
773  and end subbands */
774  dst_start_freq = get_bits(gbc, 2);
775  start_subband = get_bits(gbc, 3) + 2;
776  if (start_subband > 7)
777  start_subband += start_subband - 7;
778  end_subband = get_bits(gbc, 3) + 5;
779  if (end_subband > 7)
780  end_subband += end_subband - 7;
781  dst_start_freq = dst_start_freq * 12 + 25;
782  src_start_freq = start_subband * 12 + 25;
783  dst_end_freq = end_subband * 12 + 25;
784 
785  /* check validity of spx ranges */
786  if (start_subband >= end_subband) {
787  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
788  "range (%d >= %d)\n", start_subband, end_subband);
789  return -1;
790  }
791  if (dst_start_freq >= src_start_freq) {
792  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
793  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
794  return -1;
795  }
796 
797  s->spx_dst_start_freq = dst_start_freq;
798  s->spx_src_start_freq = src_start_freq;
799  s->spx_dst_end_freq = dst_end_freq;
800 
801  decode_band_structure(gbc, blk, s->eac3, 0,
802  start_subband, end_subband,
804  &s->num_spx_bands,
805  s->spx_band_sizes);
806  } else {
807  for (ch = 1; ch <= fbw_channels; ch++) {
808  s->channel_uses_spx[ch] = 0;
809  s->first_spx_coords[ch] = 1;
810  }
811  }
812  }
813 
814  /* spectral extension coordinates */
815  if (s->spx_in_use) {
816  for (ch = 1; ch <= fbw_channels; ch++) {
817  if (s->channel_uses_spx[ch]) {
818  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
819  float spx_blend;
820  int bin, master_spx_coord;
821 
822  s->first_spx_coords[ch] = 0;
823  spx_blend = get_bits(gbc, 5) * (1.0f/32);
824  master_spx_coord = get_bits(gbc, 2) * 3;
825 
826  bin = s->spx_src_start_freq;
827  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
828  int bandsize;
829  int spx_coord_exp, spx_coord_mant;
830  float nratio, sblend, nblend, spx_coord;
831 
832  /* calculate blending factors */
833  bandsize = s->spx_band_sizes[bnd];
834  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
835  nratio = av_clipf(nratio, 0.0f, 1.0f);
836  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
837  // to give unity variance
838  sblend = sqrtf(1.0f - nratio);
839  bin += bandsize;
840 
841  /* decode spx coordinates */
842  spx_coord_exp = get_bits(gbc, 4);
843  spx_coord_mant = get_bits(gbc, 2);
844  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
845  else spx_coord_mant += 4;
846  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
847  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
848 
849  /* multiply noise and signal blending factors by spx coordinate */
850  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
851  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
852  }
853  }
854  } else {
855  s->first_spx_coords[ch] = 1;
856  }
857  }
858  }
859 
860  /* coupling strategy */
861  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
862  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
863  if (!s->eac3)
864  s->cpl_in_use[blk] = get_bits1(gbc);
865  if (s->cpl_in_use[blk]) {
866  /* coupling in use */
867  int cpl_start_subband, cpl_end_subband;
868 
869  if (channel_mode < AC3_CHMODE_STEREO) {
870  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
871  return -1;
872  }
873 
874  /* check for enhanced coupling */
875  if (s->eac3 && get_bits1(gbc)) {
876  /* TODO: parse enhanced coupling strategy info */
877  avpriv_request_sample(s->avctx, "Enhanced coupling");
878  return AVERROR_PATCHWELCOME;
879  }
880 
881  /* determine which channels are coupled */
882  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
883  s->channel_in_cpl[1] = 1;
884  s->channel_in_cpl[2] = 1;
885  } else {
886  for (ch = 1; ch <= fbw_channels; ch++)
887  s->channel_in_cpl[ch] = get_bits1(gbc);
888  }
889 
890  /* phase flags in use */
891  if (channel_mode == AC3_CHMODE_STEREO)
892  s->phase_flags_in_use = get_bits1(gbc);
893 
894  /* coupling frequency range */
895  cpl_start_subband = get_bits(gbc, 4);
896  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
897  get_bits(gbc, 4) + 3;
898  if (cpl_start_subband >= cpl_end_subband) {
899  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
900  cpl_start_subband, cpl_end_subband);
901  return -1;
902  }
903  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
904  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
905 
906  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
907  cpl_end_subband,
909  &s->num_cpl_bands, s->cpl_band_sizes);
910  } else {
911  /* coupling not in use */
912  for (ch = 1; ch <= fbw_channels; ch++) {
913  s->channel_in_cpl[ch] = 0;
914  s->first_cpl_coords[ch] = 1;
915  }
916  s->first_cpl_leak = s->eac3;
917  s->phase_flags_in_use = 0;
918  }
919  } else if (!s->eac3) {
920  if (!blk) {
921  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
922  "be present in block 0\n");
923  return -1;
924  } else {
925  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
926  }
927  }
928  cpl_in_use = s->cpl_in_use[blk];
929 
930  /* coupling coordinates */
931  if (cpl_in_use) {
932  int cpl_coords_exist = 0;
933 
934  for (ch = 1; ch <= fbw_channels; ch++) {
935  if (s->channel_in_cpl[ch]) {
936  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
937  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
938  s->first_cpl_coords[ch] = 0;
939  cpl_coords_exist = 1;
940  master_cpl_coord = 3 * get_bits(gbc, 2);
941  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
942  cpl_coord_exp = get_bits(gbc, 4);
943  cpl_coord_mant = get_bits(gbc, 4);
944  if (cpl_coord_exp == 15)
945  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
946  else
947  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
948  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
949  }
950  } else if (!blk) {
951  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
952  "be present in block 0\n");
953  return -1;
954  }
955  } else {
956  /* channel not in coupling */
957  s->first_cpl_coords[ch] = 1;
958  }
959  }
960  /* phase flags */
961  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
962  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
963  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
964  }
965  }
966  }
967 
968  /* stereo rematrixing strategy and band structure */
969  if (channel_mode == AC3_CHMODE_STEREO) {
970  if ((s->eac3 && !blk) || get_bits1(gbc)) {
971  s->num_rematrixing_bands = 4;
972  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
973  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
974  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
976  }
977  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
978  s->rematrixing_flags[bnd] = get_bits1(gbc);
979  } else if (!blk) {
980  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
981  "new rematrixing strategy not present in block 0\n");
982  s->num_rematrixing_bands = 0;
983  }
984  }
985 
986  /* exponent strategies for each channel */
987  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
988  if (!s->eac3)
989  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
990  if (s->exp_strategy[blk][ch] != EXP_REUSE)
991  bit_alloc_stages[ch] = 3;
992  }
993 
994  /* channel bandwidth */
995  for (ch = 1; ch <= fbw_channels; ch++) {
996  s->start_freq[ch] = 0;
997  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
998  int group_size;
999  int prev = s->end_freq[ch];
1000  if (s->channel_in_cpl[ch])
1001  s->end_freq[ch] = s->start_freq[CPL_CH];
1002  else if (s->channel_uses_spx[ch])
1003  s->end_freq[ch] = s->spx_src_start_freq;
1004  else {
1005  int bandwidth_code = get_bits(gbc, 6);
1006  if (bandwidth_code > 60) {
1007  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1008  return -1;
1009  }
1010  s->end_freq[ch] = bandwidth_code * 3 + 73;
1011  }
1012  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1013  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1014  if (blk > 0 && s->end_freq[ch] != prev)
1015  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1016  }
1017  }
1018  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1020  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1021  }
1022 
1023  /* decode exponents for each channel */
1024  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1025  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1026  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1027  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1028  s->num_exp_groups[ch], s->dexps[ch][0],
1029  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1030  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1031  return -1;
1032  }
1033  if (ch != CPL_CH && ch != s->lfe_ch)
1034  skip_bits(gbc, 2); /* skip gainrng */
1035  }
1036  }
1037 
1038  /* bit allocation information */
1039  if (s->bit_allocation_syntax) {
1040  if (get_bits1(gbc)) {
1046  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1047  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1048  } else if (!blk) {
1049  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1050  "be present in block 0\n");
1051  return -1;
1052  }
1053  }
1054 
1055  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1056  if (!s->eac3 || !blk) {
1057  if (s->snr_offset_strategy && get_bits1(gbc)) {
1058  int snr = 0;
1059  int csnr;
1060  csnr = (get_bits(gbc, 6) - 15) << 4;
1061  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1062  /* snr offset */
1063  if (ch == i || s->snr_offset_strategy == 2)
1064  snr = (csnr + get_bits(gbc, 4)) << 2;
1065  /* run at least last bit allocation stage if snr offset changes */
1066  if (blk && s->snr_offset[ch] != snr) {
1067  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1068  }
1069  s->snr_offset[ch] = snr;
1070 
1071  /* fast gain (normal AC-3 only) */
1072  if (!s->eac3) {
1073  int prev = s->fast_gain[ch];
1074  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1075  /* run last 2 bit allocation stages if fast gain changes */
1076  if (blk && prev != s->fast_gain[ch])
1077  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1078  }
1079  }
1080  } else if (!s->eac3 && !blk) {
1081  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1082  return -1;
1083  }
1084  }
1085 
1086  /* fast gain (E-AC-3 only) */
1087  if (s->fast_gain_syntax && get_bits1(gbc)) {
1088  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1089  int prev = s->fast_gain[ch];
1090  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1091  /* run last 2 bit allocation stages if fast gain changes */
1092  if (blk && prev != s->fast_gain[ch])
1093  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1094  }
1095  } else if (s->eac3 && !blk) {
1096  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1097  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1098  }
1099 
1100  /* E-AC-3 to AC-3 converter SNR offset */
1101  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1102  skip_bits(gbc, 10); // skip converter snr offset
1103  }
1104 
1105  /* coupling leak information */
1106  if (cpl_in_use) {
1107  if (s->first_cpl_leak || get_bits1(gbc)) {
1108  int fl = get_bits(gbc, 3);
1109  int sl = get_bits(gbc, 3);
1110  /* run last 2 bit allocation stages for coupling channel if
1111  coupling leak changes */
1112  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1113  sl != s->bit_alloc_params.cpl_slow_leak)) {
1114  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1115  }
1118  } else if (!s->eac3 && !blk) {
1119  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1120  "be present in block 0\n");
1121  return -1;
1122  }
1123  s->first_cpl_leak = 0;
1124  }
1125 
1126  /* delta bit allocation information */
1127  if (s->dba_syntax && get_bits1(gbc)) {
1128  /* delta bit allocation exists (strategy) */
1129  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1130  s->dba_mode[ch] = get_bits(gbc, 2);
1131  if (s->dba_mode[ch] == DBA_RESERVED) {
1132  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1133  return -1;
1134  }
1135  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1136  }
1137  /* channel delta offset, len and bit allocation */
1138  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1139  if (s->dba_mode[ch] == DBA_NEW) {
1140  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1141  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1142  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1143  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1144  s->dba_values[ch][seg] = get_bits(gbc, 3);
1145  }
1146  /* run last 2 bit allocation stages if new dba values */
1147  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1148  }
1149  }
1150  } else if (blk == 0) {
1151  for (ch = 0; ch <= s->channels; ch++) {
1152  s->dba_mode[ch] = DBA_NONE;
1153  }
1154  }
1155 
1156  /* Bit allocation */
1157  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1158  if (bit_alloc_stages[ch] > 2) {
1159  /* Exponent mapping into PSD and PSD integration */
1161  s->start_freq[ch], s->end_freq[ch],
1162  s->psd[ch], s->band_psd[ch]);
1163  }
1164  if (bit_alloc_stages[ch] > 1) {
1165  /* Compute excitation function, Compute masking curve, and
1166  Apply delta bit allocation */
1168  s->start_freq[ch], s->end_freq[ch],
1169  s->fast_gain[ch], (ch == s->lfe_ch),
1170  s->dba_mode[ch], s->dba_nsegs[ch],
1171  s->dba_offsets[ch], s->dba_lengths[ch],
1172  s->dba_values[ch], s->mask[ch])) {
1173  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1174  return -1;
1175  }
1176  }
1177  if (bit_alloc_stages[ch] > 0) {
1178  /* Compute bit allocation */
1179  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1181  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1182  s->start_freq[ch], s->end_freq[ch],
1183  s->snr_offset[ch],
1185  bap_tab, s->bap[ch]);
1186  }
1187  }
1188 
1189  /* unused dummy data */
1190  if (s->skip_syntax && get_bits1(gbc)) {
1191  int skipl = get_bits(gbc, 9);
1192  while (skipl--)
1193  skip_bits(gbc, 8);
1194  }
1195 
1196  /* unpack the transform coefficients
1197  this also uncouples channels if coupling is in use. */
1198  decode_transform_coeffs(s, blk);
1199 
1200  /* TODO: generate enhanced coupling coordinates and uncouple */
1201 
1202  /* recover coefficients if rematrixing is in use */
1203  if (s->channel_mode == AC3_CHMODE_STEREO)
1204  do_rematrixing(s);
1205 
1206  /* apply scaling to coefficients (headroom, dynrng) */
1207  for (ch = 1; ch <= s->channels; ch++) {
1208  float gain = 1.0 / 4194304.0f;
1209  if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1210  gain *= s->dynamic_range[2 - ch];
1211  } else {
1212  gain *= s->dynamic_range[0];
1213  }
1215  s->fixed_coeffs[ch], gain, 256);
1216  }
1217 
1218  /* apply spectral extension to high frequency bins */
1219  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1221  }
1222 
1223  /* downmix and MDCT. order depends on whether block switching is used for
1224  any channel in this block. this is because coefficients for the long
1225  and short transforms cannot be mixed. */
1226  downmix_output = s->channels != s->out_channels &&
1227  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1228  s->fbw_channels == s->out_channels);
1229  if (different_transforms) {
1230  /* the delay samples have already been downmixed, so we upmix the delay
1231  samples in order to reconstruct all channels before downmixing. */
1232  if (s->downmixed) {
1233  s->downmixed = 0;
1234  ac3_upmix_delay(s);
1235  }
1236 
1237  do_imdct(s, s->channels);
1238 
1239  if (downmix_output) {
1240  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1241  s->out_channels, s->fbw_channels, 256);
1242  }
1243  } else {
1244  if (downmix_output) {
1245  s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1246  s->out_channels, s->fbw_channels, 256);
1247  }
1248 
1249  if (downmix_output && !s->downmixed) {
1250  s->downmixed = 1;
1252  s->fbw_channels, 128);
1253  }
1254 
1255  do_imdct(s, s->out_channels);
1256  }
1257 
1258  return 0;
1259 }
1260 
1261 /**
1262  * Decode a single AC-3 frame.
1263  */
1264 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1265  int *got_frame_ptr, AVPacket *avpkt)
1266 {
1267  AVFrame *frame = data;
1268  const uint8_t *buf = avpkt->data;
1269  int buf_size = avpkt->size;
1270  AC3DecodeContext *s = avctx->priv_data;
1271  int blk, ch, err, ret;
1272  const uint8_t *channel_map;
1273  const float *output[AC3_MAX_CHANNELS];
1274 
1275  /* copy input buffer to decoder context to avoid reading past the end
1276  of the buffer, which can be caused by a damaged input stream. */
1277  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1278  // seems to be byte-swapped AC-3
1279  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1280  s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1281  } else
1282  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1283  buf = s->input_buffer;
1284  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1285  init_get_bits(&s->gbc, buf, buf_size * 8);
1286 
1287  /* parse the syncinfo */
1288  err = parse_frame_header(s);
1289 
1290  if (err) {
1291  switch (err) {
1293  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1294  return -1;
1296  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1297  break;
1299  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1300  break;
1302  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1303  break;
1305  /* skip frame if CRC is ok. otherwise use error concealment. */
1306  /* TODO: add support for substreams and dependent frames */
1308  av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "
1309  "skipping frame\n");
1310  *got_frame_ptr = 0;
1311  return s->frame_size;
1312  } else {
1313  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1314  }
1315  break;
1316  default:
1317  av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1318  break;
1319  }
1320  } else {
1321  /* check that reported frame size fits in input buffer */
1322  if (s->frame_size > buf_size) {
1323  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1325  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1326  /* check for crc mismatch */
1327  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1328  s->frame_size - 2)) {
1329  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1331  }
1332  }
1333  }
1334 
1335  /* if frame is ok, set audio parameters */
1336  if (!err) {
1337  avctx->sample_rate = s->sample_rate;
1338  avctx->bit_rate = s->bit_rate;
1339  }
1340 
1341  /* channel config */
1342  if (!err || (s->channels && s->out_channels != s->channels)) {
1343  s->out_channels = s->channels;
1344  s->output_mode = s->channel_mode;
1345  if (s->lfe_on)
1347  if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1348  avctx->request_channels < s->channels) {
1349  s->out_channels = avctx->request_channels;
1350  s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1352  }
1353  avctx->channels = s->out_channels;
1354  avctx->channel_layout = s->channel_layout;
1355 
1356  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
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  frame->nb_samples = s->num_blocks * 256;
1378  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1379  return ret;
1380 
1381  /* decode the audio blocks */
1382  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1383  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1384  output[ch] = s->output[ch];
1385  s->outptr[ch] = s->output[ch];
1386  }
1387  for (ch = 0; ch < s->channels; ch++) {
1388  if (ch < s->out_channels)
1389  s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1390  }
1391  for (blk = 0; blk < s->num_blocks; blk++) {
1392  if (!err && decode_audio_block(s, blk)) {
1393  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1394  err = 1;
1395  }
1396  if (err)
1397  for (ch = 0; ch < s->out_channels; ch++)
1398  memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], 1024);
1399  for (ch = 0; ch < s->out_channels; ch++)
1400  output[ch] = s->outptr[channel_map[ch]];
1401  for (ch = 0; ch < s->out_channels; ch++) {
1402  if (!ch || channel_map[ch])
1403  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1404  }
1405  }
1406 
1408 
1409  /* keep last block for error concealment in next frame */
1410  for (ch = 0; ch < s->out_channels; ch++)
1411  memcpy(s->output[ch], output[ch], 1024);
1412 
1413  *got_frame_ptr = 1;
1414 
1415  return FFMIN(buf_size, s->frame_size);
1416 }
1417 
1418 /**
1419  * Uninitialize the AC-3 decoder.
1420  */
1422 {
1423  AC3DecodeContext *s = avctx->priv_data;
1424  ff_mdct_end(&s->imdct_512);
1425  ff_mdct_end(&s->imdct_256);
1426 
1427  return 0;
1428 }
1429 
1430 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1431 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1432 static const AVOption options[] = {
1433  { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1434 
1435 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1436 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1437 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1438 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1439 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1440 
1441  { NULL},
1442 };
1443 
1444 static const AVClass ac3_decoder_class = {
1445  .class_name = "AC3 decoder",
1446  .item_name = av_default_item_name,
1447  .option = options,
1448  .version = LIBAVUTIL_VERSION_INT,
1449 };
1450 
1452  .name = "ac3",
1453  .type = AVMEDIA_TYPE_AUDIO,
1454  .id = AV_CODEC_ID_AC3,
1455  .priv_data_size = sizeof (AC3DecodeContext),
1456  .init = ac3_decode_init,
1457  .close = ac3_decode_end,
1459  .capabilities = CODEC_CAP_DR1,
1460  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1461  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1463  .priv_class = &ac3_decoder_class,
1464 };
1465 
1466 #if CONFIG_EAC3_DECODER
1467 static const AVClass eac3_decoder_class = {
1468  .class_name = "E-AC3 decoder",
1469  .item_name = av_default_item_name,
1470  .option = options,
1471  .version = LIBAVUTIL_VERSION_INT,
1472 };
1473 
1474 AVCodec ff_eac3_decoder = {
1475  .name = "eac3",
1476  .type = AVMEDIA_TYPE_AUDIO,
1477  .id = AV_CODEC_ID_EAC3,
1478  .priv_data_size = sizeof (AC3DecodeContext),
1479  .init = ac3_decode_init,
1480  .close = ac3_decode_end,
1482  .capabilities = CODEC_CAP_DR1,
1483  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1484  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1486  .priv_class = &eac3_decoder_class,
1487 };
1488 #endif