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