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