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