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