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