FFmpeg
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 
33 #include "libavutil/crc.h"
34 #include "libavutil/downmix_info.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/thread.h"
37 #include "bswapdsp.h"
38 #include "internal.h"
39 #include "aac_ac3_parser.h"
40 #include "ac3_parser_internal.h"
41 #include "ac3dec.h"
42 #include "ac3dec_data.h"
43 #include "kbdwin.h"
44 
45 /**
46  * table for ungrouping 3 values in 7 bits.
47  * used for exponents and bap=2 mantissas
48  */
50 
51 /** tables for ungrouping mantissas */
52 static int b1_mantissas[32][3];
53 static int b2_mantissas[128][3];
54 static int b3_mantissas[8];
55 static int b4_mantissas[128][2];
56 static int b5_mantissas[16];
57 
58 /**
59  * Quantization table: levels for symmetric. bits for asymmetric.
60  * reference: Table 7.18 Mapping of bap to Quantizer
61  */
62 static const uint8_t quantization_tab[16] = {
63  0, 3, 5, 7, 11, 15,
64  5, 6, 7, 8, 9, 10, 11, 12, 14, 16
65 };
66 
67 #if (!USE_FIXED)
68 /** dynamic range table. converts codes to scale factors. */
69 static float dynamic_range_tab[256];
71 #endif
72 
73 /** Adjustments in dB gain */
74 static const float gain_levels[9] = {
77  LEVEL_ONE,
82  LEVEL_ZERO,
84 };
85 
86 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
87 static const float gain_levels_lfe[32] = {
88  3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
89  1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
90  0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
91  0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
92  0.125892, 0.112201, 0.100000, 0.089125
93 };
94 
95 /**
96  * Table for default stereo downmixing coefficients
97  * reference: Section 7.8.2 Downmixing Into Two Channels
98  */
99 static const uint8_t ac3_default_coeffs[8][5][2] = {
100  { { 2, 7 }, { 7, 2 }, },
101  { { 4, 4 }, },
102  { { 2, 7 }, { 7, 2 }, },
103  { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
104  { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
105  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
106  { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
107  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
108 };
109 
110 /**
111  * Symmetrical Dequantization
112  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
113  * Tables 7.19 to 7.23
114  */
115 static inline int
116 symmetric_dequant(int code, int levels)
117 {
118  return ((code - (levels >> 1)) * (1 << 24)) / levels;
119 }
120 
121 /*
122  * Initialize tables at runtime.
123  */
124 static av_cold void ac3_tables_init(void)
125 {
126  int i;
127 
128  /* generate table for ungrouping 3 values in 7 bits
129  reference: Section 7.1.3 Exponent Decoding */
130  for (i = 0; i < 128; i++) {
131  ungroup_3_in_7_bits_tab[i][0] = i / 25;
132  ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
133  ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
134  }
135 
136  /* generate grouped mantissa tables
137  reference: Section 7.3.5 Ungrouping of Mantissas */
138  for (i = 0; i < 32; i++) {
139  /* bap=1 mantissas */
143  }
144  for (i = 0; i < 128; i++) {
145  /* bap=2 mantissas */
149 
150  /* bap=4 mantissas */
151  b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
152  b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
153  }
154  /* generate ungrouped mantissa tables
155  reference: Tables 7.21 and 7.23 */
156  for (i = 0; i < 7; i++) {
157  /* bap=3 mantissas */
159  }
160  for (i = 0; i < 15; i++) {
161  /* bap=5 mantissas */
162  b5_mantissas[i] = symmetric_dequant(i, 15);
163  }
164 
165 #if (!USE_FIXED)
166  /* generate dynamic range table
167  reference: Section 7.7.1 Dynamic Range Control */
168  for (i = 0; i < 256; i++) {
169  int v = (i >> 5) - ((i >> 7) << 3) - 5;
170  dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
171  }
172 
173  /* generate compr dynamic range table
174  reference: Section 7.7.2 Heavy Compression */
175  for (i = 0; i < 256; i++) {
176  int v = (i >> 4) - ((i >> 7) << 4) - 4;
177  ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
178  }
179 #endif
180 }
181 
182 /**
183  * AVCodec initialization
184  */
186 {
187  static AVOnce init_static_once = AV_ONCE_INIT;
188  AC3DecodeContext *s = avctx->priv_data;
189  int i, ret;
190 
191  s->avctx = avctx;
192 
193  if ((ret = ff_mdct_init(&s->imdct_256, 8, 1, 1.0)) < 0 ||
194  (ret = ff_mdct_init(&s->imdct_512, 9, 1, 1.0)) < 0)
195  return ret;
196  AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
197  ff_bswapdsp_init(&s->bdsp);
198 
199 #if (USE_FIXED)
201 #else
202  ff_fmt_convert_init(&s->fmt_conv, avctx);
204 #endif
205  if (!s->fdsp)
206  return AVERROR(ENOMEM);
207 
208  ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
209  av_lfg_init(&s->dith_state, 0);
210 
211  if (USE_FIXED)
213  else
215 
216  /* allow downmixing to stereo or mono */
217  if (avctx->channels > 1 &&
219  avctx->channels = 1;
220  else if (avctx->channels > 2 &&
222  avctx->channels = 2;
223  s->downmixed = 1;
224 
225  for (i = 0; i < AC3_MAX_CHANNELS; i++) {
226  s->xcfptr[i] = s->transform_coeffs[i];
227  s->dlyptr[i] = s->delay[i];
228  }
229 
230  ff_thread_once(&init_static_once, ac3_tables_init);
231 
232  return 0;
233 }
234 
235 /**
236  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
237  * GetBitContext within AC3DecodeContext must point to
238  * the start of the synchronized AC-3 bitstream.
239  */
240 static int ac3_parse_header(AC3DecodeContext *s)
241 {
242  GetBitContext *gbc = &s->gbc;
243  int i;
244 
245  /* read the rest of the bsi. read twice for dual mono mode. */
246  i = !s->channel_mode;
247  do {
248  s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
249  if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
250  s->dialog_normalization[(!s->channel_mode)-i] = -31;
251  }
252  if (s->target_level != 0) {
253  s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
254  (float)(s->target_level -
255  s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
256  }
257  if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
258  s->heavy_dynamic_range[(!s->channel_mode)-i] =
259  AC3_HEAVY_RANGE(get_bits(gbc, 8));
260  }
261  if (get_bits1(gbc))
262  skip_bits(gbc, 8); //skip language code
263  if (get_bits1(gbc))
264  skip_bits(gbc, 7); //skip audio production information
265  } while (i--);
266 
267  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
268 
269  /* skip the timecodes or parse the Alternate Bit Stream Syntax */
270  if (s->bitstream_id != 6) {
271  if (get_bits1(gbc))
272  skip_bits(gbc, 14); //skip timecode1
273  if (get_bits1(gbc))
274  skip_bits(gbc, 14); //skip timecode2
275  } else {
276  if (get_bits1(gbc)) {
277  s->preferred_downmix = get_bits(gbc, 2);
278  s->center_mix_level_ltrt = get_bits(gbc, 3);
279  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
280  s->center_mix_level = get_bits(gbc, 3);
281  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
282  }
283  if (get_bits1(gbc)) {
284  s->dolby_surround_ex_mode = get_bits(gbc, 2);
285  s->dolby_headphone_mode = get_bits(gbc, 2);
286  skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
287  }
288  }
289 
290  /* skip additional bitstream info */
291  if (get_bits1(gbc)) {
292  i = get_bits(gbc, 6);
293  do {
294  skip_bits(gbc, 8);
295  } while (i--);
296  }
297 
298  return 0;
299 }
300 
301 /**
302  * Common function to parse AC-3 or E-AC-3 frame header
303  */
304 static int parse_frame_header(AC3DecodeContext *s)
305 {
306  AC3HeaderInfo hdr;
307  int err;
308 
309  err = ff_ac3_parse_header(&s->gbc, &hdr);
310  if (err)
311  return err;
312 
313  /* get decoding parameters from header info */
314  s->bit_alloc_params.sr_code = hdr.sr_code;
315  s->bitstream_id = hdr.bitstream_id;
316  s->bitstream_mode = hdr.bitstream_mode;
317  s->channel_mode = hdr.channel_mode;
318  s->lfe_on = hdr.lfe_on;
319  s->bit_alloc_params.sr_shift = hdr.sr_shift;
320  s->sample_rate = hdr.sample_rate;
321  s->bit_rate = hdr.bit_rate;
322  s->channels = hdr.channels;
323  s->fbw_channels = s->channels - s->lfe_on;
324  s->lfe_ch = s->fbw_channels + 1;
325  s->frame_size = hdr.frame_size;
326  s->superframe_size += hdr.frame_size;
327  s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
328  s->center_mix_level = hdr.center_mix_level;
329  s->center_mix_level_ltrt = 4; // -3.0dB
330  s->surround_mix_level = hdr.surround_mix_level;
331  s->surround_mix_level_ltrt = 4; // -3.0dB
332  s->lfe_mix_level_exists = 0;
333  s->num_blocks = hdr.num_blocks;
334  s->frame_type = hdr.frame_type;
335  s->substreamid = hdr.substreamid;
336  s->dolby_surround_mode = hdr.dolby_surround_mode;
337  s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
338  s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
339 
340  if (s->lfe_on) {
341  s->start_freq[s->lfe_ch] = 0;
342  s->end_freq[s->lfe_ch] = 7;
343  s->num_exp_groups[s->lfe_ch] = 2;
344  s->channel_in_cpl[s->lfe_ch] = 0;
345  }
346 
347  if (s->bitstream_id <= 10) {
348  s->eac3 = 0;
349  s->snr_offset_strategy = 2;
350  s->block_switch_syntax = 1;
351  s->dither_flag_syntax = 1;
352  s->bit_allocation_syntax = 1;
353  s->fast_gain_syntax = 0;
354  s->first_cpl_leak = 0;
355  s->dba_syntax = 1;
356  s->skip_syntax = 1;
357  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
358  return ac3_parse_header(s);
359  } else if (CONFIG_EAC3_DECODER) {
360  s->eac3 = 1;
361  return ff_eac3_parse_header(s);
362  } else {
363  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
364  return AVERROR(ENOSYS);
365  }
366 }
367 
368 /**
369  * Set stereo downmixing coefficients based on frame header info.
370  * reference: Section 7.8.2 Downmixing Into Two Channels
371  */
372 static int set_downmix_coeffs(AC3DecodeContext *s)
373 {
374  int i;
375  float cmix = gain_levels[s-> center_mix_level];
376  float smix = gain_levels[s->surround_mix_level];
377  float norm0, norm1;
378  float downmix_coeffs[2][AC3_MAX_CHANNELS];
379 
380  if (!s->downmix_coeffs[0]) {
381  s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
382  sizeof(**s->downmix_coeffs));
383  if (!s->downmix_coeffs[0])
384  return AVERROR(ENOMEM);
385  s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
386  }
387 
388  for (i = 0; i < s->fbw_channels; i++) {
389  downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
390  downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
391  }
392  if (s->channel_mode > 1 && s->channel_mode & 1) {
393  downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
394  }
395  if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
396  int nf = s->channel_mode - 2;
397  downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
398  }
399  if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
400  int nf = s->channel_mode - 4;
401  downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
402  }
403 
404  /* renormalize */
405  norm0 = norm1 = 0.0;
406  for (i = 0; i < s->fbw_channels; i++) {
407  norm0 += downmix_coeffs[0][i];
408  norm1 += downmix_coeffs[1][i];
409  }
410  norm0 = 1.0f / norm0;
411  norm1 = 1.0f / norm1;
412  for (i = 0; i < s->fbw_channels; i++) {
413  downmix_coeffs[0][i] *= norm0;
414  downmix_coeffs[1][i] *= norm1;
415  }
416 
417  if (s->output_mode == AC3_CHMODE_MONO) {
418  for (i = 0; i < s->fbw_channels; i++)
419  downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
420  downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
421  }
422  for (i = 0; i < s->fbw_channels; i++) {
423  s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
424  s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
425  }
426 
427  return 0;
428 }
429 
430 /**
431  * Decode the grouped exponents according to exponent strategy.
432  * reference: Section 7.1.3 Exponent Decoding
433  */
434 static int decode_exponents(AC3DecodeContext *s,
435  GetBitContext *gbc, int exp_strategy, int ngrps,
436  uint8_t absexp, int8_t *dexps)
437 {
438  int i, j, grp, group_size;
439  int dexp[256];
440  int expacc, prevexp;
441 
442  /* unpack groups */
443  group_size = exp_strategy + (exp_strategy == EXP_D45);
444  for (grp = 0, i = 0; grp < ngrps; grp++) {
445  expacc = get_bits(gbc, 7);
446  if (expacc >= 125) {
447  av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
448  return AVERROR_INVALIDDATA;
449  }
450  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
451  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
452  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
453  }
454 
455  /* convert to absolute exps and expand groups */
456  prevexp = absexp;
457  for (i = 0, j = 0; i < ngrps * 3; i++) {
458  prevexp += dexp[i] - 2;
459  if (prevexp > 24U) {
460  av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
461  return AVERROR_INVALIDDATA;
462  }
463  switch (group_size) {
464  case 4: dexps[j++] = prevexp;
465  dexps[j++] = prevexp;
466  case 2: dexps[j++] = prevexp;
467  case 1: dexps[j++] = prevexp;
468  }
469  }
470  return 0;
471 }
472 
473 /**
474  * Generate transform coefficients for each coupled channel in the coupling
475  * range using the coupling coefficients and coupling coordinates.
476  * reference: Section 7.4.3 Coupling Coordinate Format
477  */
478 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
479 {
480  int bin, band, ch;
481 
482  bin = s->start_freq[CPL_CH];
483  for (band = 0; band < s->num_cpl_bands; band++) {
484  int band_start = bin;
485  int band_end = bin + s->cpl_band_sizes[band];
486  for (ch = 1; ch <= s->fbw_channels; ch++) {
487  if (s->channel_in_cpl[ch]) {
488  int cpl_coord = s->cpl_coords[ch][band] << 5;
489  for (bin = band_start; bin < band_end; bin++) {
490  s->fixed_coeffs[ch][bin] =
491  MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
492  }
493  if (ch == 2 && s->phase_flags[band]) {
494  for (bin = band_start; bin < band_end; bin++)
495  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
496  }
497  }
498  }
499  bin = band_end;
500  }
501 }
502 
503 /**
504  * Grouped mantissas for 3-level 5-level and 11-level quantization
505  */
506 typedef struct mant_groups {
507  int b1_mant[2];
508  int b2_mant[2];
509  int b4_mant;
510  int b1;
511  int b2;
512  int b4;
513 } mant_groups;
514 
515 /**
516  * Decode the transform coefficients for a particular channel
517  * reference: Section 7.3 Quantization and Decoding of Mantissas
518  */
519 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
520 {
521  int start_freq = s->start_freq[ch_index];
522  int end_freq = s->end_freq[ch_index];
523  uint8_t *baps = s->bap[ch_index];
524  int8_t *exps = s->dexps[ch_index];
525  int32_t *coeffs = s->fixed_coeffs[ch_index];
526  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
527  GetBitContext *gbc = &s->gbc;
528  int freq;
529 
530  for (freq = start_freq; freq < end_freq; freq++) {
531  int bap = baps[freq];
532  int mantissa;
533  switch (bap) {
534  case 0:
535  /* random noise with approximate range of -0.707 to 0.707 */
536  if (dither)
537  mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
538  else
539  mantissa = 0;
540  break;
541  case 1:
542  if (m->b1) {
543  m->b1--;
544  mantissa = m->b1_mant[m->b1];
545  } else {
546  int bits = get_bits(gbc, 5);
547  mantissa = b1_mantissas[bits][0];
548  m->b1_mant[1] = b1_mantissas[bits][1];
549  m->b1_mant[0] = b1_mantissas[bits][2];
550  m->b1 = 2;
551  }
552  break;
553  case 2:
554  if (m->b2) {
555  m->b2--;
556  mantissa = m->b2_mant[m->b2];
557  } else {
558  int bits = get_bits(gbc, 7);
559  mantissa = b2_mantissas[bits][0];
560  m->b2_mant[1] = b2_mantissas[bits][1];
561  m->b2_mant[0] = b2_mantissas[bits][2];
562  m->b2 = 2;
563  }
564  break;
565  case 3:
566  mantissa = b3_mantissas[get_bits(gbc, 3)];
567  break;
568  case 4:
569  if (m->b4) {
570  m->b4 = 0;
571  mantissa = m->b4_mant;
572  } else {
573  int bits = get_bits(gbc, 7);
574  mantissa = b4_mantissas[bits][0];
575  m->b4_mant = b4_mantissas[bits][1];
576  m->b4 = 1;
577  }
578  break;
579  case 5:
580  mantissa = b5_mantissas[get_bits(gbc, 4)];
581  break;
582  default: /* 6 to 15 */
583  /* Shift mantissa and sign-extend it. */
584  if (bap > 15) {
585  av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
586  bap = 15;
587  }
588  mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
589  break;
590  }
591  coeffs[freq] = mantissa >> exps[freq];
592  }
593 }
594 
595 /**
596  * Remove random dithering from coupling range coefficients with zero-bit
597  * mantissas for coupled channels which do not use dithering.
598  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
599  */
600 static void remove_dithering(AC3DecodeContext *s) {
601  int ch, i;
602 
603  for (ch = 1; ch <= s->fbw_channels; ch++) {
604  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
605  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
606  if (!s->bap[CPL_CH][i])
607  s->fixed_coeffs[ch][i] = 0;
608  }
609  }
610  }
611 }
612 
613 static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
614  int ch, mant_groups *m)
615 {
616  if (!s->channel_uses_aht[ch]) {
618  } else {
619  /* if AHT is used, mantissas for all blocks are encoded in the first
620  block of the frame. */
621  int bin;
622  if (CONFIG_EAC3_DECODER && !blk)
624  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
625  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
626  }
627  }
628 }
629 
630 /**
631  * Decode the transform coefficients.
632  */
633 static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
634 {
635  int ch, end;
636  int got_cplchan = 0;
637  mant_groups m;
638 
639  m.b1 = m.b2 = m.b4 = 0;
640 
641  for (ch = 1; ch <= s->channels; ch++) {
642  /* transform coefficients for full-bandwidth channel */
643  decode_transform_coeffs_ch(s, blk, ch, &m);
644  /* transform coefficients for coupling channel come right after the
645  coefficients for the first coupled channel*/
646  if (s->channel_in_cpl[ch]) {
647  if (!got_cplchan) {
648  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
650  got_cplchan = 1;
651  }
652  end = s->end_freq[CPL_CH];
653  } else {
654  end = s->end_freq[ch];
655  }
656  do
657  s->fixed_coeffs[ch][end] = 0;
658  while (++end < 256);
659  }
660 
661  /* zero the dithered coefficients for appropriate channels */
662  remove_dithering(s);
663 }
664 
665 /**
666  * Stereo rematrixing.
667  * reference: Section 7.5.4 Rematrixing : Decoding Technique
668  */
669 static void do_rematrixing(AC3DecodeContext *s)
670 {
671  int bnd, i;
672  int end, bndend;
673 
674  end = FFMIN(s->end_freq[1], s->end_freq[2]);
675 
676  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
677  if (s->rematrixing_flags[bnd]) {
678  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
679  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
680  int tmp0 = s->fixed_coeffs[1][i];
681  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
682  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
683  }
684  }
685  }
686 }
687 
688 /**
689  * Inverse MDCT Transform.
690  * Convert frequency domain coefficients to time-domain audio samples.
691  * reference: Section 7.9.4 Transformation Equations
692  */
693 static inline void do_imdct(AC3DecodeContext *s, int channels, int offset)
694 {
695  int ch;
696 
697  for (ch = 1; ch <= channels; ch++) {
698  if (s->block_switch[ch]) {
699  int i;
700  FFTSample *x = s->tmp_output + 128;
701  for (i = 0; i < 128; i++)
702  x[i] = s->transform_coeffs[ch][2 * i];
703  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
704 #if USE_FIXED
705  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
706  s->tmp_output, s->window, 128, 8);
707 #else
708  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
709  s->tmp_output, s->window, 128);
710 #endif
711  for (i = 0; i < 128; i++)
712  x[i] = s->transform_coeffs[ch][2 * i + 1];
713  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
714  } else {
715  s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
716 #if USE_FIXED
717  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
718  s->tmp_output, s->window, 128, 8);
719 #else
720  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
721  s->tmp_output, s->window, 128);
722 #endif
723  memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample));
724  }
725  }
726 }
727 
728 /**
729  * Upmix delay samples from stereo to original channel layout.
730  */
731 static void ac3_upmix_delay(AC3DecodeContext *s)
732 {
733  int channel_data_size = sizeof(s->delay[0]);
734  switch (s->channel_mode) {
735  case AC3_CHMODE_DUALMONO:
736  case AC3_CHMODE_STEREO:
737  /* upmix mono to stereo */
738  memcpy(s->delay[1], s->delay[0], channel_data_size);
739  break;
740  case AC3_CHMODE_2F2R:
741  memset(s->delay[3], 0, channel_data_size);
742  case AC3_CHMODE_2F1R:
743  memset(s->delay[2], 0, channel_data_size);
744  break;
745  case AC3_CHMODE_3F2R:
746  memset(s->delay[4], 0, channel_data_size);
747  case AC3_CHMODE_3F1R:
748  memset(s->delay[3], 0, channel_data_size);
749  case AC3_CHMODE_3F:
750  memcpy(s->delay[2], s->delay[1], channel_data_size);
751  memset(s->delay[1], 0, channel_data_size);
752  break;
753  }
754 }
755 
756 /**
757  * Decode band structure for coupling, spectral extension, or enhanced coupling.
758  * The band structure defines how many subbands are in each band. For each
759  * subband in the range, 1 means it is combined with the previous band, and 0
760  * means that it starts a new band.
761  *
762  * @param[in] gbc bit reader context
763  * @param[in] blk block number
764  * @param[in] eac3 flag to indicate E-AC-3
765  * @param[in] ecpl flag to indicate enhanced coupling
766  * @param[in] start_subband subband number for start of range
767  * @param[in] end_subband subband number for end of range
768  * @param[in] default_band_struct default band structure table
769  * @param[out] num_bands number of bands (optionally NULL)
770  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
771  * @param[in,out] band_struct current band structure
772  */
773 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
774  int ecpl, int start_subband, int end_subband,
775  const uint8_t *default_band_struct,
776  int *num_bands, uint8_t *band_sizes,
777  uint8_t *band_struct, int band_struct_size)
778 {
779  int subbnd, bnd, n_subbands, n_bands=0;
780  uint8_t bnd_sz[22];
781 
782  n_subbands = end_subband - start_subband;
783 
784  if (!blk)
785  memcpy(band_struct, default_band_struct, band_struct_size);
786 
787  av_assert0(band_struct_size >= start_subband + n_subbands);
788 
789  band_struct += start_subband + 1;
790 
791  /* decode band structure from bitstream or use default */
792  if (!eac3 || get_bits1(gbc)) {
793  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
794  band_struct[subbnd] = get_bits1(gbc);
795  }
796  }
797 
798  /* calculate number of bands and band sizes based on band structure.
799  note that the first 4 subbands in enhanced coupling span only 6 bins
800  instead of 12. */
801  if (num_bands || band_sizes ) {
802  n_bands = n_subbands;
803  bnd_sz[0] = ecpl ? 6 : 12;
804  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
805  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
806  if (band_struct[subbnd - 1]) {
807  n_bands--;
808  bnd_sz[bnd] += subbnd_size;
809  } else {
810  bnd_sz[++bnd] = subbnd_size;
811  }
812  }
813  }
814 
815  /* set optional output params */
816  if (num_bands)
817  *num_bands = n_bands;
818  if (band_sizes)
819  memcpy(band_sizes, bnd_sz, n_bands);
820 }
821 
822 static inline int spx_strategy(AC3DecodeContext *s, int blk)
823 {
824  GetBitContext *bc = &s->gbc;
825  int fbw_channels = s->fbw_channels;
826  int dst_start_freq, dst_end_freq, src_start_freq,
827  start_subband, end_subband, ch;
828 
829  /* determine which channels use spx */
830  if (s->channel_mode == AC3_CHMODE_MONO) {
831  s->channel_uses_spx[1] = 1;
832  } else {
833  for (ch = 1; ch <= fbw_channels; ch++)
834  s->channel_uses_spx[ch] = get_bits1(bc);
835  }
836 
837  /* get the frequency bins of the spx copy region and the spx start
838  and end subbands */
839  dst_start_freq = get_bits(bc, 2);
840  start_subband = get_bits(bc, 3) + 2;
841  if (start_subband > 7)
842  start_subband += start_subband - 7;
843  end_subband = get_bits(bc, 3) + 5;
844 #if USE_FIXED
845  s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
846 #endif
847  if (end_subband > 7)
848  end_subband += end_subband - 7;
849  dst_start_freq = dst_start_freq * 12 + 25;
850  src_start_freq = start_subband * 12 + 25;
851  dst_end_freq = end_subband * 12 + 25;
852 
853  /* check validity of spx ranges */
854  if (start_subband >= end_subband) {
855  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
856  "range (%d >= %d)\n", start_subband, end_subband);
857  return AVERROR_INVALIDDATA;
858  }
859  if (dst_start_freq >= src_start_freq) {
860  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
861  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
862  return AVERROR_INVALIDDATA;
863  }
864 
865  s->spx_dst_start_freq = dst_start_freq;
866  s->spx_src_start_freq = src_start_freq;
867  if (!USE_FIXED)
868  s->spx_dst_end_freq = dst_end_freq;
869 
870  decode_band_structure(bc, blk, s->eac3, 0,
871  start_subband, end_subband,
873  &s->num_spx_bands,
874  s->spx_band_sizes,
875  s->spx_band_struct, sizeof(s->spx_band_struct));
876  return 0;
877 }
878 
879 static inline void spx_coordinates(AC3DecodeContext *s)
880 {
881  GetBitContext *bc = &s->gbc;
882  int fbw_channels = s->fbw_channels;
883  int ch, bnd;
884 
885  for (ch = 1; ch <= fbw_channels; ch++) {
886  if (s->channel_uses_spx[ch]) {
887  if (s->first_spx_coords[ch] || get_bits1(bc)) {
888  INTFLOAT spx_blend;
889  int bin, master_spx_coord;
890 
891  s->first_spx_coords[ch] = 0;
892  spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
893  master_spx_coord = get_bits(bc, 2) * 3;
894 
895  bin = s->spx_src_start_freq;
896  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
897  int bandsize = s->spx_band_sizes[bnd];
898  int spx_coord_exp, spx_coord_mant;
899  INTFLOAT nratio, sblend, nblend;
900 #if USE_FIXED
901  /* calculate blending factors */
902  int64_t accu = ((bin << 23) + (bandsize << 22))
903  * (int64_t)s->spx_dst_end_freq;
904  nratio = (int)(accu >> 32);
905  nratio -= spx_blend << 18;
906 
907  if (nratio < 0) {
908  nblend = 0;
909  sblend = 0x800000;
910  } else if (nratio > 0x7fffff) {
911  nblend = 14529495; // sqrt(3) in FP.23
912  sblend = 0;
913  } else {
914  nblend = fixed_sqrt(nratio, 23);
915  accu = (int64_t)nblend * 1859775393;
916  nblend = (int)((accu + (1<<29)) >> 30);
917  sblend = fixed_sqrt(0x800000 - nratio, 23);
918  }
919 #else
920  float spx_coord;
921 
922  /* calculate blending factors */
923  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
924  nratio = av_clipf(nratio, 0.0f, 1.0f);
925  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
926  // to give unity variance
927  sblend = sqrtf(1.0f - nratio);
928 #endif
929  bin += bandsize;
930 
931  /* decode spx coordinates */
932  spx_coord_exp = get_bits(bc, 4);
933  spx_coord_mant = get_bits(bc, 2);
934  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
935  else spx_coord_mant += 4;
936  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
937 
938  /* multiply noise and signal blending factors by spx coordinate */
939 #if USE_FIXED
940  accu = (int64_t)nblend * spx_coord_mant;
941  s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
942  accu = (int64_t)sblend * spx_coord_mant;
943  s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
944 #else
945  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
946  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
947  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
948 #endif
949  }
950  }
951  } else {
952  s->first_spx_coords[ch] = 1;
953  }
954  }
955 }
956 
957 static inline int coupling_strategy(AC3DecodeContext *s, int blk,
958  uint8_t *bit_alloc_stages)
959 {
960  GetBitContext *bc = &s->gbc;
961  int fbw_channels = s->fbw_channels;
962  int channel_mode = s->channel_mode;
963  int ch;
964 
965  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
966  if (!s->eac3)
967  s->cpl_in_use[blk] = get_bits1(bc);
968  if (s->cpl_in_use[blk]) {
969  /* coupling in use */
970  int cpl_start_subband, cpl_end_subband;
971 
972  if (channel_mode < AC3_CHMODE_STEREO) {
973  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
974  return AVERROR_INVALIDDATA;
975  }
976 
977  /* check for enhanced coupling */
978  if (s->eac3 && get_bits1(bc)) {
979  /* TODO: parse enhanced coupling strategy info */
980  avpriv_request_sample(s->avctx, "Enhanced coupling");
981  return AVERROR_PATCHWELCOME;
982  }
983 
984  /* determine which channels are coupled */
985  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
986  s->channel_in_cpl[1] = 1;
987  s->channel_in_cpl[2] = 1;
988  } else {
989  for (ch = 1; ch <= fbw_channels; ch++)
990  s->channel_in_cpl[ch] = get_bits1(bc);
991  }
992 
993  /* phase flags in use */
994  if (channel_mode == AC3_CHMODE_STEREO)
995  s->phase_flags_in_use = get_bits1(bc);
996 
997  /* coupling frequency range */
998  cpl_start_subband = get_bits(bc, 4);
999  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1000  get_bits(bc, 4) + 3;
1001  if (cpl_start_subband >= cpl_end_subband) {
1002  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1003  cpl_start_subband, cpl_end_subband);
1004  return AVERROR_INVALIDDATA;
1005  }
1006  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1007  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1008 
1009  decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1010  cpl_end_subband,
1012  &s->num_cpl_bands, s->cpl_band_sizes,
1013  s->cpl_band_struct, sizeof(s->cpl_band_struct));
1014  } else {
1015  /* coupling not in use */
1016  for (ch = 1; ch <= fbw_channels; ch++) {
1017  s->channel_in_cpl[ch] = 0;
1018  s->first_cpl_coords[ch] = 1;
1019  }
1020  s->first_cpl_leak = s->eac3;
1021  s->phase_flags_in_use = 0;
1022  }
1023 
1024  return 0;
1025 }
1026 
1027 static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1028 {
1029  GetBitContext *bc = &s->gbc;
1030  int fbw_channels = s->fbw_channels;
1031  int ch, bnd;
1032  int cpl_coords_exist = 0;
1033 
1034  for (ch = 1; ch <= fbw_channels; ch++) {
1035  if (s->channel_in_cpl[ch]) {
1036  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1037  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1038  s->first_cpl_coords[ch] = 0;
1039  cpl_coords_exist = 1;
1040  master_cpl_coord = 3 * get_bits(bc, 2);
1041  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1042  cpl_coord_exp = get_bits(bc, 4);
1043  cpl_coord_mant = get_bits(bc, 4);
1044  if (cpl_coord_exp == 15)
1045  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1046  else
1047  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1048  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1049  }
1050  } else if (!blk) {
1051  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1052  "be present in block 0\n");
1053  return AVERROR_INVALIDDATA;
1054  }
1055  } else {
1056  /* channel not in coupling */
1057  s->first_cpl_coords[ch] = 1;
1058  }
1059  }
1060  /* phase flags */
1061  if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1062  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1063  s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1064  }
1065  }
1066 
1067  return 0;
1068 }
1069 
1070 /**
1071  * Decode a single audio block from the AC-3 bitstream.
1072  */
1073 static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1074 {
1075  int fbw_channels = s->fbw_channels;
1076  int channel_mode = s->channel_mode;
1077  int i, bnd, seg, ch, ret;
1078  int different_transforms;
1079  int downmix_output;
1080  int cpl_in_use;
1081  GetBitContext *gbc = &s->gbc;
1082  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1083 
1084  /* block switch flags */
1085  different_transforms = 0;
1086  if (s->block_switch_syntax) {
1087  for (ch = 1; ch <= fbw_channels; ch++) {
1088  s->block_switch[ch] = get_bits1(gbc);
1089  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1090  different_transforms = 1;
1091  }
1092  }
1093 
1094  /* dithering flags */
1095  if (s->dither_flag_syntax) {
1096  for (ch = 1; ch <= fbw_channels; ch++) {
1097  s->dither_flag[ch] = get_bits1(gbc);
1098  }
1099  }
1100 
1101  /* dynamic range */
1102  i = !s->channel_mode;
1103  do {
1104  if (get_bits1(gbc)) {
1105  /* Allow asymmetric application of DRC when drc_scale > 1.
1106  Amplification of quiet sounds is enhanced */
1107  int range_bits = get_bits(gbc, 8);
1108  INTFLOAT range = AC3_RANGE(range_bits);
1109  if (range_bits <= 127 || s->drc_scale <= 1.0)
1110  s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1111  else
1112  s->dynamic_range[i] = range;
1113  } else if (blk == 0) {
1114  s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1115  }
1116  } while (i--);
1117 
1118  /* spectral extension strategy */
1119  if (s->eac3 && (!blk || get_bits1(gbc))) {
1120  s->spx_in_use = get_bits1(gbc);
1121  if (s->spx_in_use) {
1122  if ((ret = spx_strategy(s, blk)) < 0)
1123  return ret;
1124  }
1125  }
1126  if (!s->eac3 || !s->spx_in_use) {
1127  s->spx_in_use = 0;
1128  for (ch = 1; ch <= fbw_channels; ch++) {
1129  s->channel_uses_spx[ch] = 0;
1130  s->first_spx_coords[ch] = 1;
1131  }
1132  }
1133 
1134  /* spectral extension coordinates */
1135  if (s->spx_in_use)
1136  spx_coordinates(s);
1137 
1138  /* coupling strategy */
1139  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1140  if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1141  return ret;
1142  } else if (!s->eac3) {
1143  if (!blk) {
1144  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1145  "be present in block 0\n");
1146  return AVERROR_INVALIDDATA;
1147  } else {
1148  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1149  }
1150  }
1151  cpl_in_use = s->cpl_in_use[blk];
1152 
1153  /* coupling coordinates */
1154  if (cpl_in_use) {
1155  if ((ret = coupling_coordinates(s, blk)) < 0)
1156  return ret;
1157  }
1158 
1159  /* stereo rematrixing strategy and band structure */
1160  if (channel_mode == AC3_CHMODE_STEREO) {
1161  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1162  s->num_rematrixing_bands = 4;
1163  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1164  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1165  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1166  s->num_rematrixing_bands--;
1167  }
1168  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1169  s->rematrixing_flags[bnd] = get_bits1(gbc);
1170  } else if (!blk) {
1171  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1172  "new rematrixing strategy not present in block 0\n");
1173  s->num_rematrixing_bands = 0;
1174  }
1175  }
1176 
1177  /* exponent strategies for each channel */
1178  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1179  if (!s->eac3)
1180  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1181  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1182  bit_alloc_stages[ch] = 3;
1183  }
1184 
1185  /* channel bandwidth */
1186  for (ch = 1; ch <= fbw_channels; ch++) {
1187  s->start_freq[ch] = 0;
1188  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1189  int group_size;
1190  int prev = s->end_freq[ch];
1191  if (s->channel_in_cpl[ch])
1192  s->end_freq[ch] = s->start_freq[CPL_CH];
1193  else if (s->channel_uses_spx[ch])
1194  s->end_freq[ch] = s->spx_src_start_freq;
1195  else {
1196  int bandwidth_code = get_bits(gbc, 6);
1197  if (bandwidth_code > 60) {
1198  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1199  return AVERROR_INVALIDDATA;
1200  }
1201  s->end_freq[ch] = bandwidth_code * 3 + 73;
1202  }
1203  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1204  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1205  if (blk > 0 && s->end_freq[ch] != prev)
1206  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1207  }
1208  }
1209  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1210  s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1211  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1212  }
1213 
1214  /* decode exponents for each channel */
1215  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1216  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1217  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1218  if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1219  s->num_exp_groups[ch], s->dexps[ch][0],
1220  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1221  return AVERROR_INVALIDDATA;
1222  }
1223  if (ch != CPL_CH && ch != s->lfe_ch)
1224  skip_bits(gbc, 2); /* skip gainrng */
1225  }
1226  }
1227 
1228  /* bit allocation information */
1229  if (s->bit_allocation_syntax) {
1230  if (get_bits1(gbc)) {
1231  s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1232  s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1233  s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1234  s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1235  s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1236  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1237  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1238  } else if (!blk) {
1239  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1240  "be present in block 0\n");
1241  return AVERROR_INVALIDDATA;
1242  }
1243  }
1244 
1245  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1246  if (!s->eac3 || !blk) {
1247  if (s->snr_offset_strategy && get_bits1(gbc)) {
1248  int snr = 0;
1249  int csnr;
1250  csnr = (get_bits(gbc, 6) - 15) << 4;
1251  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1252  /* snr offset */
1253  if (ch == i || s->snr_offset_strategy == 2)
1254  snr = (csnr + get_bits(gbc, 4)) << 2;
1255  /* run at least last bit allocation stage if snr offset changes */
1256  if (blk && s->snr_offset[ch] != snr) {
1257  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1258  }
1259  s->snr_offset[ch] = snr;
1260 
1261  /* fast gain (normal AC-3 only) */
1262  if (!s->eac3) {
1263  int prev = s->fast_gain[ch];
1264  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1265  /* run last 2 bit allocation stages if fast gain changes */
1266  if (blk && prev != s->fast_gain[ch])
1267  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1268  }
1269  }
1270  } else if (!s->eac3 && !blk) {
1271  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1272  return AVERROR_INVALIDDATA;
1273  }
1274  }
1275 
1276  /* fast gain (E-AC-3 only) */
1277  if (s->fast_gain_syntax && get_bits1(gbc)) {
1278  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1279  int prev = s->fast_gain[ch];
1280  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1281  /* run last 2 bit allocation stages if fast gain changes */
1282  if (blk && prev != s->fast_gain[ch])
1283  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1284  }
1285  } else if (s->eac3 && !blk) {
1286  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1287  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1288  }
1289 
1290  /* E-AC-3 to AC-3 converter SNR offset */
1291  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1292  skip_bits(gbc, 10); // skip converter snr offset
1293  }
1294 
1295  /* coupling leak information */
1296  if (cpl_in_use) {
1297  if (s->first_cpl_leak || get_bits1(gbc)) {
1298  int fl = get_bits(gbc, 3);
1299  int sl = get_bits(gbc, 3);
1300  /* run last 2 bit allocation stages for coupling channel if
1301  coupling leak changes */
1302  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1303  sl != s->bit_alloc_params.cpl_slow_leak)) {
1304  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1305  }
1306  s->bit_alloc_params.cpl_fast_leak = fl;
1307  s->bit_alloc_params.cpl_slow_leak = sl;
1308  } else if (!s->eac3 && !blk) {
1309  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1310  "be present in block 0\n");
1311  return AVERROR_INVALIDDATA;
1312  }
1313  s->first_cpl_leak = 0;
1314  }
1315 
1316  /* delta bit allocation information */
1317  if (s->dba_syntax && get_bits1(gbc)) {
1318  /* delta bit allocation exists (strategy) */
1319  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1320  s->dba_mode[ch] = get_bits(gbc, 2);
1321  if (s->dba_mode[ch] == DBA_RESERVED) {
1322  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1323  return AVERROR_INVALIDDATA;
1324  }
1325  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1326  }
1327  /* channel delta offset, len and bit allocation */
1328  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1329  if (s->dba_mode[ch] == DBA_NEW) {
1330  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1331  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1332  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1333  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1334  s->dba_values[ch][seg] = get_bits(gbc, 3);
1335  }
1336  /* run last 2 bit allocation stages if new dba values */
1337  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1338  }
1339  }
1340  } else if (blk == 0) {
1341  for (ch = 0; ch <= s->channels; ch++) {
1342  s->dba_mode[ch] = DBA_NONE;
1343  }
1344  }
1345 
1346  /* Bit allocation */
1347  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1348  if (bit_alloc_stages[ch] > 2) {
1349  /* Exponent mapping into PSD and PSD integration */
1350  ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1351  s->start_freq[ch], s->end_freq[ch],
1352  s->psd[ch], s->band_psd[ch]);
1353  }
1354  if (bit_alloc_stages[ch] > 1) {
1355  /* Compute excitation function, Compute masking curve, and
1356  Apply delta bit allocation */
1357  if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1358  s->start_freq[ch], s->end_freq[ch],
1359  s->fast_gain[ch], (ch == s->lfe_ch),
1360  s->dba_mode[ch], s->dba_nsegs[ch],
1361  s->dba_offsets[ch], s->dba_lengths[ch],
1362  s->dba_values[ch], s->mask[ch])) {
1363  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1364  return AVERROR_INVALIDDATA;
1365  }
1366  }
1367  if (bit_alloc_stages[ch] > 0) {
1368  /* Compute bit allocation */
1369  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1371  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1372  s->start_freq[ch], s->end_freq[ch],
1373  s->snr_offset[ch],
1374  s->bit_alloc_params.floor,
1375  bap_tab, s->bap[ch]);
1376  }
1377  }
1378 
1379  /* unused dummy data */
1380  if (s->skip_syntax && get_bits1(gbc)) {
1381  int skipl = get_bits(gbc, 9);
1382  skip_bits_long(gbc, 8 * skipl);
1383  }
1384 
1385  /* unpack the transform coefficients
1386  this also uncouples channels if coupling is in use. */
1387  decode_transform_coeffs(s, blk);
1388 
1389  /* TODO: generate enhanced coupling coordinates and uncouple */
1390 
1391  /* recover coefficients if rematrixing is in use */
1392  if (s->channel_mode == AC3_CHMODE_STEREO)
1393  do_rematrixing(s);
1394 
1395  /* apply scaling to coefficients (headroom, dynrng) */
1396  for (ch = 1; ch <= s->channels; ch++) {
1397  int audio_channel = 0;
1398  INTFLOAT gain;
1399  if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1400  audio_channel = 2-ch;
1401  if (s->heavy_compression && s->compression_exists[audio_channel])
1402  gain = s->heavy_dynamic_range[audio_channel];
1403  else
1404  gain = s->dynamic_range[audio_channel];
1405 
1406 #if USE_FIXED
1407  scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1408 #else
1409  if (s->target_level != 0)
1410  gain = gain * s->level_gain[audio_channel];
1411  gain *= 1.0 / 4194304.0f;
1412  s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1413  s->fixed_coeffs[ch], gain, 256);
1414 #endif
1415  }
1416 
1417  /* apply spectral extension to high frequency bins */
1418  if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1420  }
1421 
1422  /* downmix and MDCT. order depends on whether block switching is used for
1423  any channel in this block. this is because coefficients for the long
1424  and short transforms cannot be mixed. */
1425  downmix_output = s->channels != s->out_channels &&
1426  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1427  s->fbw_channels == s->out_channels);
1428  if (different_transforms) {
1429  /* the delay samples have already been downmixed, so we upmix the delay
1430  samples in order to reconstruct all channels before downmixing. */
1431  if (s->downmixed) {
1432  s->downmixed = 0;
1433  ac3_upmix_delay(s);
1434  }
1435 
1436  do_imdct(s, s->channels, offset);
1437 
1438  if (downmix_output) {
1439 #if USE_FIXED
1440  ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1441  s->out_channels, s->fbw_channels, 256);
1442 #else
1443  ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
1444  s->out_channels, s->fbw_channels, 256);
1445 #endif
1446  }
1447  } else {
1448  if (downmix_output) {
1449  AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1450  s->out_channels, s->fbw_channels, 256);
1451  }
1452 
1453  if (downmix_output && !s->downmixed) {
1454  s->downmixed = 1;
1455  AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
1456  s->out_channels, s->fbw_channels, 128);
1457  }
1458 
1459  do_imdct(s, s->out_channels, offset);
1460  }
1461 
1462  return 0;
1463 }
1464 
1465 /**
1466  * Decode a single AC-3 frame.
1467  */
1468 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1469  int *got_frame_ptr, AVPacket *avpkt)
1470 {
1471  AVFrame *frame = data;
1472  const uint8_t *buf = avpkt->data;
1473  int buf_size, full_buf_size = avpkt->size;
1474  AC3DecodeContext *s = avctx->priv_data;
1475  int blk, ch, err, offset, ret;
1476  int i;
1477  int skip = 0, got_independent_frame = 0;
1478  const uint8_t *channel_map;
1479  uint8_t extended_channel_map[EAC3_MAX_CHANNELS];
1481  enum AVMatrixEncoding matrix_encoding;
1482  AVDownmixInfo *downmix_info;
1483 
1484  s->superframe_size = 0;
1485 
1486  buf_size = full_buf_size;
1487  for (i = 1; i < buf_size; i += 2) {
1488  if (buf[i] == 0x77 || buf[i] == 0x0B) {
1489  if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1490  i--;
1491  break;
1492  } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1493  break;
1494  }
1495  }
1496  }
1497  if (i >= buf_size)
1498  return AVERROR_INVALIDDATA;
1499  if (i > 10)
1500  return i;
1501  buf += i;
1502  buf_size -= i;
1503 
1504  /* copy input buffer to decoder context to avoid reading past the end
1505  of the buffer, which can be caused by a damaged input stream. */
1506  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1507  // seems to be byte-swapped AC-3
1508  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1509  s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1510  (const uint16_t *) buf, cnt);
1511  } else
1512  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1513 
1514  /* if consistent noise generation is enabled, seed the linear feedback generator
1515  * with the contents of the AC-3 frame so that the noise is identical across
1516  * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1517  if (s->consistent_noise_generation)
1518  av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1519 
1520  buf = s->input_buffer;
1521 dependent_frame:
1522  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1523  if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1524  return ret;
1525 
1526  /* parse the syncinfo */
1527  err = parse_frame_header(s);
1528 
1529  if (err) {
1530  switch (err) {
1532  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1533  return AVERROR_INVALIDDATA;
1535  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1536  break;
1538  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1539  break;
1541  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1542  break;
1544  /* skip frame if CRC is ok. otherwise use error concealment. */
1545  /* TODO: add support for substreams */
1546  if (s->substreamid) {
1547  av_log(avctx, AV_LOG_DEBUG,
1548  "unsupported substream %d: skipping frame\n",
1549  s->substreamid);
1550  *got_frame_ptr = 0;
1551  return buf_size;
1552  } else {
1553  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1554  }
1555  break;
1558  break;
1559  default: // Normal AVERROR do not try to recover.
1560  *got_frame_ptr = 0;
1561  return err;
1562  }
1563  } else {
1564  /* check that reported frame size fits in input buffer */
1565  if (s->frame_size > buf_size) {
1566  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1568  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1569  /* check for crc mismatch */
1570  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1571  s->frame_size - 2)) {
1572  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1573  if (avctx->err_recognition & AV_EF_EXPLODE)
1574  return AVERROR_INVALIDDATA;
1576  }
1577  }
1578  }
1579 
1580  if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
1581  av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
1582  *got_frame_ptr = 0;
1583  return FFMIN(full_buf_size, s->frame_size);
1584  }
1585 
1586  /* channel config */
1587  if (!err || (s->channels && s->out_channels != s->channels)) {
1588  s->out_channels = s->channels;
1589  s->output_mode = s->channel_mode;
1590  if (s->lfe_on)
1591  s->output_mode |= AC3_OUTPUT_LFEON;
1592  if (s->channels > 1 &&
1594  s->out_channels = 1;
1595  s->output_mode = AC3_CHMODE_MONO;
1596  } else if (s->channels > 2 &&
1598  s->out_channels = 2;
1599  s->output_mode = AC3_CHMODE_STEREO;
1600  }
1601 
1602  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1603  s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1604  s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1605  s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1606  /* set downmixing coefficients if needed */
1607  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1608  s->fbw_channels == s->out_channels)) {
1609  if ((ret = set_downmix_coeffs(s)) < 0) {
1610  av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1611  return ret;
1612  }
1613  }
1614  } else if (!s->channels) {
1615  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1616  return AVERROR_INVALIDDATA;
1617  }
1618  avctx->channels = s->out_channels;
1619  avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1620  if (s->output_mode & AC3_OUTPUT_LFEON)
1622 
1623  /* set audio service type based on bitstream mode for AC-3 */
1624  avctx->audio_service_type = s->bitstream_mode;
1625  if (s->bitstream_mode == 0x7 && s->channels > 1)
1627 
1628  /* decode the audio blocks */
1629  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1630  offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1631  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1632  output[ch] = s->output[ch + offset];
1633  s->outptr[ch] = s->output[ch + offset];
1634  }
1635  for (ch = 0; ch < s->channels; ch++) {
1636  if (ch < s->out_channels)
1637  s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1638  }
1639  for (blk = 0; blk < s->num_blocks; blk++) {
1640  if (!err && decode_audio_block(s, blk, offset)) {
1641  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1642  err = 1;
1643  }
1644  if (err)
1645  for (ch = 0; ch < s->out_channels; ch++)
1646  memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1647  for (ch = 0; ch < s->out_channels; ch++)
1648  output[ch] = s->outptr[channel_map[ch]];
1649  for (ch = 0; ch < s->out_channels; ch++) {
1650  if (!ch || channel_map[ch])
1651  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1652  }
1653  }
1654 
1655  /* keep last block for error concealment in next frame */
1656  for (ch = 0; ch < s->out_channels; ch++)
1657  memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1658 
1659  /* check if there is dependent frame */
1660  if (buf_size > s->frame_size) {
1661  AC3HeaderInfo hdr;
1662  int err;
1663 
1664  if (buf_size - s->frame_size <= 16) {
1665  skip = buf_size - s->frame_size;
1666  goto skip;
1667  }
1668 
1669  if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1670  return ret;
1671 
1672  err = ff_ac3_parse_header(&s->gbc, &hdr);
1673  if (err)
1674  return err;
1675 
1677  if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) {
1678  av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n");
1679  } else {
1680  buf += s->frame_size;
1681  buf_size -= s->frame_size;
1682  s->prev_output_mode = s->output_mode;
1683  s->prev_bit_rate = s->bit_rate;
1684  got_independent_frame = 1;
1685  goto dependent_frame;
1686  }
1687  }
1688  }
1689 skip:
1690 
1692 
1693  /* if frame is ok, set audio parameters */
1694  if (!err) {
1695  avctx->sample_rate = s->sample_rate;
1696  avctx->bit_rate = s->bit_rate + s->prev_bit_rate;
1697  }
1698 
1699  for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1700  extended_channel_map[ch] = ch;
1701 
1702  if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1703  uint64_t ich_layout = avpriv_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON];
1704  int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1705  uint64_t channel_layout;
1706  int extend = 0;
1707 
1708  if (s->prev_output_mode & AC3_OUTPUT_LFEON)
1709  ich_layout |= AV_CH_LOW_FREQUENCY;
1710 
1711  channel_layout = ich_layout;
1712  for (ch = 0; ch < 16; ch++) {
1713  if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1714  channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
1715  }
1716  }
1717  if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
1718  av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
1719  av_get_channel_layout_nb_channels(channel_layout));
1720  return AVERROR_INVALIDDATA;
1721  }
1722 
1723  avctx->channel_layout = channel_layout;
1724  avctx->channels = av_get_channel_layout_nb_channels(channel_layout);
1725 
1726  for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
1727  if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1729  int index = av_get_channel_layout_channel_index(channel_layout,
1731  if (index < 0)
1732  return AVERROR_INVALIDDATA;
1733  if (extend >= channel_map_size)
1734  return AVERROR_INVALIDDATA;
1735 
1736  extended_channel_map[index] = offset + channel_map[extend++];
1737  } else {
1738  int i;
1739 
1740  for (i = 0; i < 64; i++) {
1741  if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
1742  int index = av_get_channel_layout_channel_index(channel_layout,
1743  1ULL << i);
1744  if (index < 0)
1745  return AVERROR_INVALIDDATA;
1746  if (extend >= channel_map_size)
1747  return AVERROR_INVALIDDATA;
1748 
1749  extended_channel_map[index] = offset + channel_map[extend++];
1750  }
1751  }
1752  }
1753  }
1754  }
1755  }
1756 
1757  /* get output buffer */
1758  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1759  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1760  return ret;
1761 
1762  for (ch = 0; ch < avctx->channels; ch++) {
1763  int map = extended_channel_map[ch];
1764  av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
1765  memcpy((SHORTFLOAT *)frame->extended_data[ch],
1766  s->output_buffer[map],
1767  s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
1768  }
1769 
1770  /*
1771  * AVMatrixEncoding
1772  *
1773  * Check whether the input layout is compatible, and make sure we're not
1774  * downmixing (else the matrix encoding is no longer applicable).
1775  */
1776  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1777  if (s->channel_mode == AC3_CHMODE_STEREO &&
1778  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1779  if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1780  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1781  else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1782  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1783  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1784  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1785  switch (s->dolby_surround_ex_mode) {
1786  case AC3_DSUREXMOD_ON: // EX or PLIIx
1787  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1788  break;
1789  case AC3_DSUREXMOD_PLIIZ:
1790  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1791  break;
1792  default: // not indicated or off
1793  break;
1794  }
1795  }
1796  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1797  return ret;
1798 
1799  /* AVDownmixInfo */
1800  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1801  switch (s->preferred_downmix) {
1802  case AC3_DMIXMOD_LTRT:
1804  break;
1805  case AC3_DMIXMOD_LORO:
1807  break;
1808  case AC3_DMIXMOD_DPLII:
1810  break;
1811  default:
1813  break;
1814  }
1815  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1816  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1817  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1818  downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1819  if (s->lfe_mix_level_exists)
1820  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1821  else
1822  downmix_info->lfe_mix_level = 0.0; // -inf dB
1823  } else
1824  return AVERROR(ENOMEM);
1825 
1826  *got_frame_ptr = 1;
1827 
1828  if (!s->superframe_size)
1829  return FFMIN(full_buf_size, s->frame_size + skip);
1830 
1831  return FFMIN(full_buf_size, s->superframe_size + skip);
1832 }
1833 
1834 /**
1835  * Uninitialize the AC-3 decoder.
1836  */
1838 {
1839  AC3DecodeContext *s = avctx->priv_data;
1840  ff_mdct_end(&s->imdct_512);
1841  ff_mdct_end(&s->imdct_256);
1842  av_freep(&s->fdsp);
1843  av_freep(&s->downmix_coeffs[0]);
1844 
1845  return 0;
1846 }
1847 
1848 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1849 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
audio downmix medatata
uint8_t bitstream_mode
Definition: ac3.h:184
float, planar
Definition: samplefmt.h:69
static int coupling_strategy(AC3DecodeContext *s, int blk, uint8_t *bit_alloc_stages)
Definition: ac3dec.c:957
void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix, int out_ch, int in_ch, int len)
Definition: ac3dsp.c:336
const uint8_t ff_ac3_bap_tab[64]
Definition: ac3tab.c:214
static const uint8_t ac3_default_coeffs[8][5][2]
Table for default stereo downmixing coefficients reference: Section 7.8.2 Downmixing Into Two Channel...
Definition: ac3dec.c:99
int ff_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)
Parse AC-3 frame header.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_NUM_DATA_POINTERS
Definition: frame.h:319
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static int spx_strategy(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:822
const uint8_t ff_eac3_default_spx_band_struct[17]
Table E2.15 Default Spectral Extension Banding Structure.
Definition: ac3dec_data.c:59
const uint8_t ff_ac3_slow_decay_tab[4]
Definition: ac3tab.c:224
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
Definition: kbdwin.c:26
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
const uint8_t ff_ac3_ungroup_3_in_5_bits_tab[32][3]
Table used to ungroup 3 values stored in 5 bits.
Definition: ac3dec_data.c:35
static int ff_eac3_parse_header(AC3DecodeContext *s)
Definition: eac3dec.c:289
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
#define avpriv_request_sample(...)
double center_mix_level_ltrt
Absolute scale factor representing the nominal level of the center channel during an Lt/Rt compatible...
Definition: downmix_info.h:74
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:104
AVDownmixInfo * av_downmix_info_update_side_data(AVFrame *frame)
Get a frame&#39;s AV_FRAME_DATA_DOWNMIX_INFO side data for editing.
Definition: downmix_info.c:24
int size
Definition: packet.h:370
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
Decode the transform coefficients for a particular channel reference: Section 7.3 Quantization and De...
Definition: ac3dec.c:519
int b4
Definition: ac3dec.c:512
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, mant_groups *m)
Definition: ac3dec.c:613
#define EXP_REUSE
Definition: ac3.h:47
#define AV_CH_LAYOUT_STEREO
const uint16_t ff_ac3_slow_gain_tab[4]
Definition: ac3tab.c:232
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:91
#define blk(i)
Definition: sha.c:185
fg index
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
Not indicated.
Definition: downmix_info.h:45
static void spx_coordinates(AC3DecodeContext *s)
Definition: ac3dec.c:879
static void scale_coefs(int32_t *dst, const int32_t *src, int dynrng, int len)
Definition: ac3dec_fixed.c:61
#define USE_FIXED
Definition: aac_defines.h:25
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1261
float INTFLOAT
Definition: aac_defines.h:88
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
uint8_t
#define av_cold
Definition: attributes.h:88
AVOptions.
uint8_t lfe_on
Definition: ac3.h:186
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
Definition: ac3dec.c:1837
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
static uint8_t ungroup_3_in_7_bits_tab[128][3]
table for ungrouping 3 values in 7 bits.
Definition: ac3dec.c:49
#define AV_CH_LOW_FREQUENCY
Public header for CRC hash function implementation.
#define av_clip
Definition: common.h:122
uint8_t * data
Definition: packet.h:369
double surround_mix_level_ltrt
Absolute scale factor representing the nominal level of the surround channels during an Lt/Rt compati...
Definition: downmix_info.h:86
static int b1_mantissas[32][3]
tables for ungrouping mantissas
Definition: ac3dec.c:52
uint8_t sr_shift
Definition: ac3.h:199
#define FIXR12(x)
Definition: ac3.h:82
Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible.
Definition: downmix_info.h:48
uint8_t bitstream_id
Definition: ac3.h:183
#define LEVEL_MINUS_1POINT5DB
Definition: ac3.h:105
static av_always_inline int fixed_sqrt(int x, int bits)
Calculate the square root.
Definition: fixed_dsp.h:176
channels
Definition: aptx.h:33
#define AVOnce
Definition: thread.h:172
#define av_log(a,...)
double lfe_mix_level
Absolute scale factor representing the level at which the LFE data is mixed into L/R channels during ...
Definition: downmix_info.h:92
static void do_imdct(AC3DecodeContext *s, int channels, int offset)
Inverse MDCT Transform.
Definition: ac3dec.c:693
static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
Definition: eac3dec.c:196
Grouped mantissas for 3-level 5-level and 11-level quantization.
Definition: ac3dec.c:506
#define av_clipf
Definition: common.h:170
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:89
This structure describes optional metadata relevant to a downmix procedure.
Definition: downmix_info.h:58
#define U(x)
Definition: vp56_arith.h:37
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define AC3_DYNAMIC_RANGE1
Definition: ac3.h:93
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
const uint8_t ff_ac3_fast_decay_tab[4]
Definition: ac3tab.c:228
uint8_t frame_type
Definition: ac3.h:187
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
Decode the transform coefficients.
Definition: ac3dec.c:633
uint8_t sr_code
Definition: ac3.h:182
static const uint8_t dither[8][8]
Definition: vf_fspp.c:59
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define LEVEL_MINUS_9DB
Definition: ac3.h:109
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:31
static const uint8_t bap_tab[64]
Definition: dolby_e.c:589
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, int start, int end, int fast_gain, int is_lfe, int dba_mode, int dba_nsegs, uint8_t *dba_offsets, uint8_t *dba_lengths, uint8_t *dba_values, int16_t *mask)
Calculate the masking curve.
Definition: ac3.c:118
Definition: ac3.h:116
Coded AC-3 header values up to the lfeon element, plus derived values.
Definition: ac3.h:176
uint8_t bits
Definition: vp3data.h:141
#define ff_mdct_init
Definition: fft.h:161
uint16_t sample_rate
Definition: ac3.h:200
#define FFMAX(a, b)
Definition: common.h:103
#define LEVEL_MINUS_3DB
Definition: ac3.h:106
float FFTSample
Definition: avfft.h:35
static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
Decode a single audio block from the AC-3 bitstream.
Definition: ac3dec.c:1073
static int ac3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single AC-3 frame.
Definition: ac3dec.c:1468
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
#define LEVEL_MINUS_4POINT5DB
Definition: ac3.h:107
static int b3_mantissas[8]
Definition: ac3dec.c:54
#define AC3_BLOCK_SIZE
Definition: ac3.h:35
static int set_downmix_coeffs(AC3DecodeContext *s)
Set stereo downmixing coefficients based on frame header info.
Definition: ac3dec.c:372
#define powf(x, y)
Definition: libm.h:50
static float dynamic_range_tab[256]
dynamic range table.
Definition: ac3dec.c:69
static void do_rematrixing(AC3DecodeContext *s)
Stereo rematrixing.
Definition: ac3dec.c:669
#define AC3_HEAVY_RANGE(x)
Definition: ac3.h:90
audio channel layout utility functions
int b4_mant
Definition: ac3dec.c:509
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
static int b5_mantissas[16]
Definition: ac3dec.c:56
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
#define FFMIN(a, b)
Definition: common.h:105
Lt/Rt 2-channel downmix, Dolby Surround compatible.
Definition: downmix_info.h:47
uint32_t bit_rate
Definition: ac3.h:201
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:368
int32_t
const uint16_t ff_ac3_fast_gain_tab[8]
Definition: ac3tab.c:244
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int b2_mantissas[128][3]
Definition: ac3dec.c:53
Lo/Ro 2-channel downmix (Stereo).
Definition: downmix_info.h:46
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
float SHORTFLOAT
Definition: aac_defines.h:91
av_cold void ff_fmt_convert_init(FmtConvertContext *c, AVCodecContext *avctx)
Definition: fmtconvert.c:52
Definition: ac3.h:117
int dolby_surround_mode
Definition: ac3.h:193
static int b4_mantissas[128][2]
Definition: ac3dec.c:55
#define AC3_RANGE(x)
Definition: ac3.h:89
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3, int ecpl, int start_subband, int end_subband, const uint8_t *default_band_struct, int *num_bands, uint8_t *band_sizes, uint8_t *band_struct, int band_struct_size)
Decode band structure for coupling, spectral extension, or enhanced coupling.
Definition: ac3dec.c:773
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Definition: utils.c:114
int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length)
Seed the state of the ALFG using binary data.
Definition: lfg.c:64
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
double surround_mix_level
Absolute scale factor representing the nominal level of the surround channels during a regular downmi...
Definition: downmix_info.h:80
#define CPL_CH
coupling channel index
Definition: ac3.h:32
#define AV_ONCE_INIT
Definition: thread.h:173
const uint8_t ff_eac3_default_cpl_band_struct[18]
Table E2.16 Default Coupling Banding Structure.
Definition: ac3tab.c:128
int sample_rate
samples per second
Definition: avcodec.h:1196
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:536
#define LEVEL_ZERO
Definition: ac3.h:110
#define LEVEL_ONE
Definition: ac3.h:111
static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
Definition: eac3dec.c:59
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
static const float gain_levels[9]
Adjustments in dB gain.
Definition: ac3dec.c:74
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
Definition: avcodec.h:1659
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int b1
Definition: ac3dec.c:510
static const int end_freq_inv_tab[8]
Definition: ac3dec_fixed.c:56
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
uint16_t frame_size
Definition: ac3.h:203
static int decode_exponents(AC3DecodeContext *s, GetBitContext *gbc, int exp_strategy, int ngrps, uint8_t absexp, int8_t *dexps)
Decode the grouped exponents according to exponent strategy.
Definition: ac3dec.c:434
static const uint8_t quantization_tab[16]
Quantization table: levels for symmetric.
Definition: ac3dec.c:62
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:1653
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
const VDPAUPixFmtMap * map
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:614
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:240
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
Definition: frame.h:613
int av_get_channel_layout_channel_index(uint64_t channel_layout, uint64_t channel)
Get the index of a channel in channel_layout.
static int coupling_coordinates(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:1027
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static int ac3_parse_header(AC3DecodeContext *s)
Parse the &#39;sync info&#39; and &#39;bit stream info&#39; from the AC-3 bitstream.
Definition: ac3dec.c:240
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
AVFixedDSPContext * avpriv_alloc_fixed_dsp(int bit_exact)
Allocate and initialize a fixed DSP context.
Definition: fixed_dsp.c:149
#define AC3_DYNAMIC_RANGE(x)
Definition: ac3.h:91
const uint64_t ff_eac3_custom_channel_map_locations[16][2]
Definition: ac3tab.c:248
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int
const uint8_t ff_ac3_channels_tab[8]
Map audio coding mode (acmod) to number of full-bandwidth channels.
Definition: ac3tab.c:82
common internal api header.
#define ff_mdct_end
Definition: fft.h:162
int surround_mix_level
Surround mix level index.
Definition: ac3.h:190
int b1_mant[2]
Definition: ac3dec.c:507
int center_mix_level
Center mix level index.
Definition: ac3.h:189
static void ac3_downmix_c_fixed16(int16_t **samples, int16_t **matrix, int out_ch, int in_ch, int len)
Downmix samples from original signal to stereo or mono (this is for 16-bit samples and fixed point de...
Definition: ac3dec_fixed.c:129
static av_cold void ac3_tables_init(void)
Definition: ac3dec.c:124
double center_mix_level
Absolute scale factor representing the nominal level of the center channel during a regular downmix...
Definition: downmix_info.h:68
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:563
void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd, int16_t *band_psd)
Calculate the log power-spectral density of the input signal.
Definition: ac3.c:92
#define EAC3_MAX_CHANNELS
maximum number of channels in EAC3
Definition: ac3.h:30
#define AC3_SPX_BLEND(x)
Definition: ac3.h:92
static int parse_frame_header(AC3DecodeContext *s)
Common function to parse AC-3 or E-AC-3 frame header.
Definition: ac3dec.c:304
#define LEVEL_PLUS_3DB
Definition: ac3.h:103
int b2_mant[2]
Definition: ac3dec.c:508
int substreamid
substream identification
Definition: ac3.h:188
int channels
number of audio channels
Definition: avcodec.h:1197
uint8_t channels
Definition: ac3.h:202
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
Generate transform coefficients for each coupled channel in the coupling range using the coupling coe...
Definition: ac3dec.c:478
static const float gain_levels_lfe[32]
Adjustments in dB gain (LFE, +10 to -21 dB)
Definition: ac3dec.c:87
#define LEVEL_MINUS_6DB
Definition: ac3.h:108
static int symmetric_dequant(int code, int levels)
Symmetrical Dequantization reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantizati...
Definition: ac3dec.c:116
#define av_freep(p)
static void ac3_upmix_delay(AC3DecodeContext *s)
Upmix delay samples from stereo to original channel layout.
Definition: ac3dec.c:731
const uint8_t ff_ac3_rematrix_band_tab[5]
Table of bin locations for rematrixing bands reference: Section 7.5.2 Rematrixing : Frequency Band De...
Definition: ac3tab.c:123
signed 16 bits, planar
Definition: samplefmt.h:67
const uint8_t ff_eac3_hebap_tab[64]
Definition: ac3dec_data.c:46
#define av_malloc_array(a, b)
const uint8_t ff_ac3_dec_channel_map[8][2][6]
Table to remap channels from AC-3 order to SMPTE order.
Definition: ac3tab.c:104
AVMatrixEncoding
int num_blocks
number of audio blocks
Definition: ac3.h:192
uint8_t channel_mode
Definition: ac3.h:185
static av_cold int ac3_decode_init(AVCodecContext *avctx)
AVCodec initialization.
Definition: ac3dec.c:185
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:236
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:365
#define AV_CH_LAYOUT_MONO
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1254
static void remove_dithering(AC3DecodeContext *s)
Remove random dithering from coupling range coefficients with zero-bit mantissas for coupled channels...
Definition: ac3dec.c:600
This structure stores compressed data.
Definition: packet.h:346
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
#define EXP_D45
Definition: ac3.h:52
float ff_ac3_heavy_dynamic_range_tab[256]
Definition: ac3dec.c:70
for(j=16;j >0;--j)
int i
Definition: input.c:407
#define AC3_RENAME(x)
Definition: ac3.h:86
enum AVDownmixType preferred_downmix_type
Type of downmix preferred by the mastering engineer.
Definition: downmix_info.h:62
int b2
Definition: ac3dec.c:511
#define MULH
Definition: mathops.h:42