FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 */
157  b3_mantissas[i] = symmetric_dequant(i, 7);
158  }
159  for (i = 0; i < 15; i++) {
160  /* bap=5 mantissas */
161  b5_mantissas[i] = symmetric_dequant(i, 15);
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 
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  */
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  */
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 */
309  s->bitstream_id = hdr.bitstream_id;
311  s->channel_mode = hdr.channel_mode;
312  s->lfe_on = hdr.lfe_on;
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;
323  s->center_mix_level_ltrt = 4; // -3.0dB
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;
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  */
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]) {
376  sizeof(**s->downmix_coeffs));
377  if (!s->downmix_coeffs[0])
378  return AVERROR(ENOMEM);
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  }
390  int nf = s->channel_mode - 2;
391  downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
392  }
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  */
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 -1;
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  */
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  */
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  */
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 
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  */
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) {
642  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
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 */
656  remove_dithering(s);
657 }
658 
659 /**
660  * Stereo rematrixing.
661  * reference: Section 7.5.4 Rematrixing : Decoding Technique
662  */
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 {
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  */
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  */
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) {
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) {
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)) {
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  }
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 */
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 */
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],
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. */
1381  decode_transform_coeffs(s, blk);
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;
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
1435  s->out_channels, s->fbw_channels, 256);
1436 #else
1438  s->out_channels, s->fbw_channels, 256);
1439 #endif
1440  }
1441  } else {
1442  if (downmix_output) {
1444  s->out_channels, s->fbw_channels, 256);
1445  }
1446 
1447  if (downmix_output && !s->downmixed) {
1448  s->downmixed = 1;
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 skip = 0, got_independent_frame = 0;
1471  const uint8_t *channel_map;
1472  uint8_t extended_channel_map[EAC3_MAX_CHANNELS];
1473  const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1474  enum AVMatrixEncoding matrix_encoding;
1475  AVDownmixInfo *downmix_info;
1476 
1477  s->superframe_size = 0;
1478 
1479  buf_size = full_buf_size;
1480  while (buf_size > 2) {
1481  if (AV_RB16(buf) != 0x770B && AV_RL16(buf) != 0x770B) {
1482  buf += 1;
1483  buf_size -= 1;
1484  continue;
1485  }
1486  break;
1487  }
1488  /* copy input buffer to decoder context to avoid reading past the end
1489  of the buffer, which can be caused by a damaged input stream. */
1490  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1491  // seems to be byte-swapped AC-3
1492  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1493  s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1494  (const uint16_t *) buf, cnt);
1495  } else
1496  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1497 
1498  /* if consistent noise generation is enabled, seed the linear feedback generator
1499  * with the contents of the AC-3 frame so that the noise is identical across
1500  * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1503 
1504  buf = s->input_buffer;
1505 dependent_frame:
1506  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1507  if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1508  return ret;
1509 
1510  /* parse the syncinfo */
1511  err = parse_frame_header(s);
1512 
1513  if (err) {
1514  switch (err) {
1516  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1517  return AVERROR_INVALIDDATA;
1519  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1520  break;
1522  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1523  break;
1525  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1526  break;
1528  /* skip frame if CRC is ok. otherwise use error concealment. */
1529  /* TODO: add support for substreams */
1530  if (s->substreamid) {
1531  av_log(avctx, AV_LOG_DEBUG,
1532  "unsupported substream %d: skipping frame\n",
1533  s->substreamid);
1534  *got_frame_ptr = 0;
1535  return buf_size;
1536  } else {
1537  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1538  }
1539  break;
1542  break;
1543  default: // Normal AVERROR do not try to recover.
1544  *got_frame_ptr = 0;
1545  return err;
1546  }
1547  } else {
1548  /* check that reported frame size fits in input buffer */
1549  if (s->frame_size > buf_size) {
1550  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1552  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1553  /* check for crc mismatch */
1554  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1555  s->frame_size - 2)) {
1556  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1557  if (avctx->err_recognition & AV_EF_EXPLODE)
1558  return AVERROR_INVALIDDATA;
1560  }
1561  }
1562  }
1563 
1564  if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
1565  av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
1566  *got_frame_ptr = 0;
1567  return FFMIN(full_buf_size, s->frame_size);
1568  }
1569 
1570  /* channel config */
1571  if (!err || (s->channels && s->out_channels != s->channels)) {
1572  s->out_channels = s->channels;
1573  s->output_mode = s->channel_mode;
1574  if (s->lfe_on)
1576  if (s->channels > 1 &&
1578  s->out_channels = 1;
1580  } else if (s->channels > 2 &&
1582  s->out_channels = 2;
1584  }
1585 
1586  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1590  /* set downmixing coefficients if needed */
1591  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1592  s->fbw_channels == s->out_channels)) {
1593  if ((ret = set_downmix_coeffs(s)) < 0) {
1594  av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1595  return ret;
1596  }
1597  }
1598  } else if (!s->channels) {
1599  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1600  return AVERROR_INVALIDDATA;
1601  }
1602  avctx->channels = s->out_channels;
1604  if (s->output_mode & AC3_OUTPUT_LFEON)
1606 
1607  /* set audio service type based on bitstream mode for AC-3 */
1608  avctx->audio_service_type = s->bitstream_mode;
1609  if (s->bitstream_mode == 0x7 && s->channels > 1)
1611 
1612  /* decode the audio blocks */
1613  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1615  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1616  output[ch] = s->output[ch + offset];
1617  s->outptr[ch] = s->output[ch + offset];
1618  }
1619  for (ch = 0; ch < s->channels; ch++) {
1620  if (ch < s->out_channels)
1621  s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1622  }
1623  for (blk = 0; blk < s->num_blocks; blk++) {
1624  if (!err && decode_audio_block(s, blk, offset)) {
1625  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1626  err = 1;
1627  }
1628  if (err)
1629  for (ch = 0; ch < s->out_channels; ch++)
1630  memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1631  for (ch = 0; ch < s->out_channels; ch++)
1632  output[ch] = s->outptr[channel_map[ch]];
1633  for (ch = 0; ch < s->out_channels; ch++) {
1634  if (!ch || channel_map[ch])
1635  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1636  }
1637  }
1638 
1639  /* keep last block for error concealment in next frame */
1640  for (ch = 0; ch < s->out_channels; ch++)
1641  memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1642 
1643  /* check if there is dependent frame */
1644  if (buf_size > s->frame_size) {
1645  AC3HeaderInfo hdr;
1646  int err;
1647 
1648  if (buf_size - s->frame_size <= 16) {
1649  skip = buf_size - s->frame_size;
1650  goto skip;
1651  }
1652 
1653  if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1654  return ret;
1655 
1656  err = ff_ac3_parse_header(&s->gbc, &hdr);
1657  if (err)
1658  return err;
1659 
1661  if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) {
1662  av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n");
1663  } else {
1664  buf += s->frame_size;
1665  buf_size -= s->frame_size;
1666  s->prev_output_mode = s->output_mode;
1667  s->prev_bit_rate = s->bit_rate;
1668  got_independent_frame = 1;
1669  goto dependent_frame;
1670  }
1671  }
1672  }
1673 skip:
1674 
1676 
1677  /* if frame is ok, set audio parameters */
1678  if (!err) {
1679  avctx->sample_rate = s->sample_rate;
1680  avctx->bit_rate = s->bit_rate + s->prev_bit_rate;
1681  }
1682 
1683  for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1684  extended_channel_map[ch] = ch;
1685 
1688  int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1689  uint64_t channel_layout;
1690  int extend = 0;
1691 
1693  ich_layout |= AV_CH_LOW_FREQUENCY;
1694 
1695  channel_layout = ich_layout;
1696  for (ch = 0; ch < 16; ch++) {
1697  if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1698  channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
1699  }
1700  }
1701  if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
1702  av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
1703  av_get_channel_layout_nb_channels(channel_layout));
1704  return AVERROR_INVALIDDATA;
1705  }
1706 
1707  avctx->channel_layout = channel_layout;
1708  avctx->channels = av_get_channel_layout_nb_channels(channel_layout);
1709 
1710  for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
1711  if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1713  int index = av_get_channel_layout_channel_index(channel_layout,
1715  if (index < 0)
1716  return AVERROR_INVALIDDATA;
1717  if (extend >= channel_map_size)
1718  return AVERROR_INVALIDDATA;
1719 
1720  extended_channel_map[index] = offset + channel_map[extend++];
1721  } else {
1722  int i;
1723 
1724  for (i = 0; i < 64; i++) {
1725  if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
1726  int index = av_get_channel_layout_channel_index(channel_layout,
1727  1ULL << i);
1728  if (index < 0)
1729  return AVERROR_INVALIDDATA;
1730  if (extend >= channel_map_size)
1731  return AVERROR_INVALIDDATA;
1732 
1733  extended_channel_map[index] = offset + channel_map[extend++];
1734  }
1735  }
1736  }
1737  }
1738  }
1739  }
1740 
1741  /* get output buffer */
1742  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1743  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1744  return ret;
1745 
1746  for (ch = 0; ch < avctx->channels; ch++) {
1747  int map = extended_channel_map[ch];
1748  av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
1749  memcpy((SHORTFLOAT *)frame->extended_data[ch],
1750  s->output_buffer[map],
1751  s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
1752  }
1753 
1754  /*
1755  * AVMatrixEncoding
1756  *
1757  * Check whether the input layout is compatible, and make sure we're not
1758  * downmixing (else the matrix encoding is no longer applicable).
1759  */
1760  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1761  if (s->channel_mode == AC3_CHMODE_STEREO &&
1762  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1764  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1766  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1767  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1768  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1769  switch (s->dolby_surround_ex_mode) {
1770  case AC3_DSUREXMOD_ON: // EX or PLIIx
1771  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1772  break;
1773  case AC3_DSUREXMOD_PLIIZ:
1774  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1775  break;
1776  default: // not indicated or off
1777  break;
1778  }
1779  }
1780  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1781  return ret;
1782 
1783  /* AVDownmixInfo */
1784  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1785  switch (s->preferred_downmix) {
1786  case AC3_DMIXMOD_LTRT:
1788  break;
1789  case AC3_DMIXMOD_LORO:
1791  break;
1792  case AC3_DMIXMOD_DPLII:
1794  break;
1795  default:
1797  break;
1798  }
1799  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1800  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1801  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1803  if (s->lfe_mix_level_exists)
1804  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1805  else
1806  downmix_info->lfe_mix_level = 0.0; // -inf dB
1807  } else
1808  return AVERROR(ENOMEM);
1809 
1810  *got_frame_ptr = 1;
1811 
1812  if (!s->superframe_size)
1813  return FFMIN(full_buf_size, s->frame_size + skip);
1814 
1815  return FFMIN(full_buf_size, s->superframe_size + skip);
1816 }
1817 
1818 /**
1819  * Uninitialize the AC-3 decoder.
1820  */
1822 {
1823  AC3DecodeContext *s = avctx->priv_data;
1824  ff_mdct_end(&s->imdct_512);
1825  ff_mdct_end(&s->imdct_256);
1826  av_freep(&s->fdsp);
1827  av_freep(&s->downmix_coeffs[0]);
1828 
1829  return 0;
1830 }
1831 
1832 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1833 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
audio downmix medatata
SHORTFLOAT * downmix_coeffs[2]
stereo downmix coefficients
Definition: ac3dec.h:165
uint8_t bitstream_mode
Definition: ac3.h:185
float, planar
Definition: samplefmt.h:69
static int coupling_strategy(AC3DecodeContext *s, int blk, uint8_t *bit_alloc_stages)
Definition: ac3dec.c:951
void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix, int out_ch, int in_ch, int len)
Definition: ac3dsp.c:390
const uint8_t ff_ac3_bap_tab[64]
Definition: ac3tab.c:270
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
int dba_nsegs[AC3_MAX_CHANNELS]
number of delta segments
Definition: ac3dec.h:210
int ff_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)
Parse AC-3 frame header.
uint8_t input_buffer[AC3_FRAME_BUFFER_SIZE+AV_INPUT_BUFFER_PADDING_SIZE]
temp buffer to prevent overread
Definition: ac3dec.h:249
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_NUM_DATA_POINTERS
Definition: frame.h:227
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
int16_t psd[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
scaled exponents
Definition: ac3dec.h:206
int spx_in_use
spectral extension in use (spxinu)
Definition: ac3dec.h:141
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static int spx_strategy(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:816
uint8_t dba_offsets[AC3_MAX_CHANNELS][8]
delta segment offsets
Definition: ac3dec.h:211
const uint8_t ff_eac3_default_spx_band_struct[17]
Table E2.15 Default Spectral Extension Banding Structure.
Definition: ac3dec_data.c:59
const uint8_t ff_ac3_slow_decay_tab[4]
Definition: ac3tab.c:280
int dither_flag[AC3_MAX_CHANNELS]
dither flags (dithflg)
Definition: ac3dec.h:217
int16_t mask[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
masking curve values
Definition: ac3dec.h:208
int preferred_downmix
Preferred 2-channel downmix mode (dmixmod)
Definition: ac3dec.h:92
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
Definition: kbdwin.c:26
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1590
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
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:293
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
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
channels
Definition: aptx.c:30
static const uint8_t bap_tab[64]
Definition: dolby_e.h:632
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:105
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
int size
Definition: avcodec.h:1453
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
int channels
number of total channels
Definition: ac3dec.h:163
int b4
Definition: ac3dec.c:506
AVFloatDSPContext * fdsp
Definition: ac3dec.h:232
int spx_dst_end_freq
spx end frequency bin
Definition: ac3dec.h:145
SHORTFLOAT output[EAC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
output after imdct transform and windowing
Definition: ac3dec.h:248
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, mant_groups *m)
Definition: ac3dec.c:607
#define EXP_REUSE
Definition: ac3.h:48
int exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS]
exponent strategies (expstr)
Definition: ac3dec.h:197
int lfe_on
lfe channel in use
Definition: ac3dec.h:87
#define AV_CH_LAYOUT_STEREO
const uint16_t ff_ac3_slow_gain_tab[4]
Definition: ac3tab.c:288
int block_switch[AC3_MAX_CHANNELS]
block switch flags (blksw)
Definition: ac3dec.h:222
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:87
#define blk(i)
Definition: sha.c:185
int dba_syntax
delta bit allocation syntax enabled (dbaflde)
Definition: ac3dec.h:121
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
int dialog_normalization[2]
dialog level in dBFS (dialnorm)
Definition: ac3dec.h:88
int spx_src_start_freq
spx start frequency bin
Definition: ac3dec.h:144
int heavy_compression
apply heavy compression
Definition: ac3dec.h:176
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:361
Not indicated.
Definition: downmix_info.h:45
static void spx_coordinates(AC3DecodeContext *s)
Definition: ac3dec.c:873
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3dec.h:133
static void scale_coefs(int32_t *dst, const int32_t *src, int dynrng, int len)
Definition: ac3dec_fixed.c:61
#define USE_FIXED
Definition: aac_defines.h:25
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define AC3_FRAME_BUFFER_SIZE
Large enough for maximum possible frame size when the specification limit is ignored.
Definition: ac3dec.h:68
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:2261
int lfe_mix_level_exists
indicates if lfemixlevcod is specified (lfemixlevcode)
Definition: ac3dec.h:97
float INTFLOAT
Definition: aac_defines.h:86
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t spx_band_struct[SPX_MAX_BANDS]
Definition: ac3dec.h:149
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2204
float ltrt_center_mix_level
Definition: ac3dec.h:108
uint8_t
#define av_cold
Definition: attributes.h:82
int first_cpl_coords[AC3_MAX_CHANNELS]
first coupling coordinates states (firstcplcos)
Definition: ac3dec.h:135
AVOptions.
uint8_t lfe_on
Definition: ac3.h:187
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
INTFLOAT spx_noise_blend[AC3_MAX_CHANNELS][SPX_MAX_BANDS]
spx noise blending factor (nblendfact)
Definition: ac3dec.h:152
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
Definition: ac3dec.c:1821
static uint8_t ungroup_3_in_7_bits_tab[128][3]
table for ungrouping 3 values in 7 bits.
Definition: ac3dec.c:48
static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
Decode mantissas in a single channel for the entire frame.
int num_rematrixing_bands
number of rematrixing bands (nrematbnd)
Definition: ac3dec.h:190
#define AV_CH_LOW_FREQUENCY
int fast_gain[AC3_MAX_CHANNELS]
fast gain values/SMR's (fgain)
Definition: ac3dec.h:204
static AVFrame * frame
Public header for CRC hash function implementation.
float ltrt_surround_mix_level
Definition: ac3dec.h:109
uint8_t * data
Definition: avcodec.h:1452
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
int cpl_coords[AC3_MAX_CHANNELS][AC3_MAX_CPL_BANDS]
coupling coordinates (cplco)
Definition: ac3dec.h:136
static int b1_mantissas[32][3]
tables for ungrouping mantissas
Definition: ac3dec.c:51
int num_exp_groups[AC3_MAX_CHANNELS]
Number of exponent groups (nexpgrp)
Definition: ac3dec.h:195
uint8_t sr_shift
Definition: ac3.h:200
#define FIXR12(x)
Definition: ac3.h:83
Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible.
Definition: downmix_info.h:48
uint8_t bitstream_id
Definition: ac3.h:184
#define LEVEL_MINUS_1POINT5DB
Definition: ac3.h:106
static av_always_inline int fixed_sqrt(int x, int bits)
Calculate the square root.
Definition: fixed_dsp.h:176
static int ff_eac3_parse_header(AC3DecodeContext *s)
Parse the E-AC-3 frame header.
int bit_allocation_syntax
bit allocation model syntax enabled (bamode)
Definition: ac3dec.h:119
int phase_flags_in_use
phase flags in use (phsflginu)
Definition: ac3dec.h:129
#define av_log(a,...)
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
Common code between the AC-3 and E-AC-3 decoders.
static void do_imdct(AC3DecodeContext *s, int channels, int offset)
Inverse MDCT Transform.
Definition: ac3dec.c:687
Grouped mantissas for 3-level 5-level and 11-level quantization.
Definition: ac3dec.c:500
int phase_flags[AC3_MAX_CPL_BANDS]
phase flags (phsflg)
Definition: ac3dec.h:130
int out_channels
number of output channels
Definition: ac3dec.h:169
int channel_map
custom channel map (chanmap)
Definition: ac3dec.h:91
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:89
This structure describes optional metadata relevant to a downmix procedure.
Definition: downmix_info.h:58
int consistent_noise_generation
seed noise generation with AC-3 frame on decode
Definition: ac3dec.h:186
#define U(x)
Definition: vp56_arith.h:37
int substreamid
substream identification
Definition: ac3dec.h:78
FFTContext imdct_256
for 256 sample IMDCT
Definition: ac3dec.h:224
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AC3_DYNAMIC_RANGE1
Definition: ac3.h:94
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
const uint8_t ff_ac3_fast_decay_tab[4]
Definition: ac3tab.c:284
int bit_rate
stream bit rate, in bits-per-second
Definition: ac3dec.h:81
uint8_t frame_type
Definition: ac3.h:188
int lfe_ch
index of LFE channel
Definition: ac3dec.h:164
#define AVERROR(e)
Definition: error.h:43
uint8_t first_spx_coords[AC3_MAX_CHANNELS]
first spx coordinates states (firstspxcos)
Definition: ac3dec.h:151
AC3BitAllocParameters bit_alloc_params
bit allocation parameters
Definition: ac3dec.h:201
int dolby_surround_mode
dolby surround mode (dsurmod)
Definition: ac3dec.h:102
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
Decode the transform coefficients.
Definition: ac3dec.c:627
GetBitContext gbc
bitstream reader
Definition: ac3dec.h:73
uint8_t sr_code
Definition: ac3.h:183
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57
AC3DSPContext ac3dsp
Definition: ac3dec.h:234
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define LEVEL_MINUS_9DB
Definition: ac3.h:110
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:32
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1620
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
Definition: ac3.h:117
int superframe_size
current superframe size, in bytes
Definition: ac3dec.h:79
int dolby_headphone_mode
dolby headphone mode (dheadphonmod)
Definition: ac3dec.h:104
float loro_center_mix_level
Definition: ac3dec.h:110
Coded AC-3 header values up to the lfeon element, plus derived values.
Definition: ac3.h:177
int compression_exists[2]
compression field is valid for frame (compre)
Definition: ac3dec.h:89
#define ff_mdct_init
Definition: fft.h:169
uint16_t sample_rate
Definition: ac3.h:201
INTFLOAT transform_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
transform coefficients
Definition: ac3dec.h:244
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define FFMAX(a, b)
Definition: common.h:94
#define LEVEL_MINUS_3DB
Definition: ac3.h:107
float FFTSample
Definition: avfft.h:35
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
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
int block_switch_syntax
block switch syntax enabled (blkswe)
Definition: ac3dec.h:117
float level_gain[2]
Definition: ac3dec.h:113
int fast_gain_syntax
fast gain codes enabled (frmfgaincode)
Definition: ac3dec.h:120
int16_t band_psd[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
interpolated exponents
Definition: ac3dec.h:207
uint8_t channel_uses_spx[AC3_MAX_CHANNELS]
channel uses spectral extension (chinspx)
Definition: ac3dec.h:142
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2247
#define LEVEL_MINUS_4POINT5DB
Definition: ac3.h:108
static int b3_mantissas[8]
Definition: ac3dec.c:53
#define AC3_BLOCK_SIZE
Definition: ac3.h:36
static int set_downmix_coeffs(AC3DecodeContext *s)
Set stereo downmixing coefficients based on frame header info.
Definition: ac3dec.c:366
INTFLOAT dynamic_range[2]
dynamic range
Definition: ac3dec.h:174
#define powf(x, y)
Definition: libm.h:50
static float dynamic_range_tab[256]
dynamic range table.
Definition: ac3dec.c:68
INTFLOAT window[AC3_BLOCK_SIZE]
window coefficients
Definition: ac3dec.h:246
static void do_rematrixing(AC3DecodeContext *s)
Stereo rematrixing.
Definition: ac3dec.c:663
#define AC3_HEAVY_RANGE(x)
Definition: ac3.h:91
SHORTFLOAT * outptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:238
audio channel layout utility functions
int b4_mant
Definition: ac3dec.c:503
int surround_mix_level_ltrt
Surround mix level index for Lt/Rt (ltrtsurmixlev)
Definition: ac3dec.h:96
BswapDSPContext bdsp
Definition: ac3dec.h:228
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:895
static int b5_mantissas[16]
Definition: ac3dec.c:55
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2665
float loro_surround_mix_level
Definition: ac3dec.h:111
#define FFMIN(a, b)
Definition: common.h:96
Lt/Rt 2-channel downmix, Dolby Surround compatible.
Definition: downmix_info.h:47
int dither_flag_syntax
dither flag syntax enabled (dithflage)
Definition: ac3dec.h:118
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3dec.h:182
INTFLOAT heavy_dynamic_range[2]
heavy dynamic range compression
Definition: ac3dec.h:177
uint32_t bit_rate
Definition: ac3.h:202
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:422
INTFLOAT tmp_output[AC3_BLOCK_SIZE]
temporary storage for output before windowing
Definition: ac3dec.h:247
uint8_t dba_values[AC3_MAX_CHANNELS][8]
delta values for each segment
Definition: ac3dec.h:213
SHORTFLOAT output_buffer[EAC3_MAX_CHANNELS][AC3_BLOCK_SIZE *6]
final output buffer
Definition: ac3dec.h:250
FFTContext imdct_512
for 512 sample IMDCT
Definition: ac3dec.h:223
int32_t
const uint16_t ff_ac3_fast_gain_tab[8]
Definition: ac3tab.c:300
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
void(* int32_to_float_fmul_scalar)(float *dst, const int32_t *src, float mul, int len)
Convert an array of int32_t to float and multiply by a float value.
Definition: fmtconvert.h:38
static int b2_mantissas[128][3]
Definition: ac3dec.c:52
Lo/Ro 2-channel downmix (Stereo).
Definition: downmix_info.h:46
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2676
float SHORTFLOAT
Definition: aac_defines.h:89
av_cold void ff_fmt_convert_init(FmtConvertContext *c, AVCodecContext *avctx)
Definition: fmtconvert.c:52
Definition: ac3.h:118
int dolby_surround_mode
Definition: ac3.h:194
AVCodecContext * avctx
parent context
Definition: ac3dec.h:72
static int b4_mantissas[128][2]
Definition: ac3dec.c:54
#define AC3_RANGE(x)
Definition: ac3.h:90
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
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
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
int channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3dec.h:128
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int fbw_channels
number of full-bandwidth channels
Definition: ac3dec.h:162
void(* bit_alloc_calc_bap)(int16_t *mask, int16_t *psd, int start, int end, int snr_offset, int floor, const uint8_t *bap_tab, uint8_t *bap)
Calculate bit allocation pointers.
Definition: ac3dsp.h:106
INTFLOAT * xcfptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:239
uint8_t bap[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
bit allocation pointers
Definition: ac3dec.h:205
double surround_mix_level
Absolute scale factor representing the nominal level of the surround channels during a regular downmi...
Definition: downmix_info.h:80
#define CPL_CH
coupling channel index
Definition: ac3.h:33
const uint8_t ff_eac3_default_cpl_band_struct[18]
Table E2.16 Default Coupling Banding Structure.
Definition: ac3tab.c:146
uint8_t cpl_band_struct[AC3_MAX_CPL_BANDS]
Definition: ac3dec.h:132
int sample_rate
samples per second
Definition: avcodec.h:2196
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:650
main external API structure.
Definition: avcodec.h:1540
#define LEVEL_ZERO
Definition: ac3.h:111
#define LEVEL_ONE
Definition: ac3.h:112
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1919
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:47
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3dec.h:131
int num_spx_bands
number of spx bands (nspxbnds)
Definition: ac3dec.h:148
void * buf
Definition: avisynth_c.h:690
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
static const float gain_levels[9]
Adjustments in dB gain.
Definition: ac3dec.c:73
#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:2679
static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
Apply spectral extension to each channel by copying lower frequency coefficients to higher frequency ...
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:487
int b1
Definition: ac3dec.c:504
static const int end_freq_inv_tab[8]
Definition: ac3dec_fixed.c:56
INTFLOAT spx_signal_blend[AC3_MAX_CHANNELS][SPX_MAX_BANDS]
spx signal blending factor (sblendfact)
Definition: ac3dec.h:153
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:460
int index
Definition: gxfenc.c:89
int bitstream_mode
bitstream mode (bsmod)
Definition: ac3dec.h:85
int center_mix_level_ltrt
Center mix level index for Lt/Rt (ltrtcmixlev)
Definition: ac3dec.h:94
int frame_type
frame type (strmtyp)
Definition: ac3dec.h:77
uint16_t frame_size
Definition: ac3.h:204
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
static const uint8_t quantization_tab[16]
Quantization table: levels for symmetric.
Definition: ac3dec.c:61
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2673
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
INTFLOAT delay[EAC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
delay - added to the next block
Definition: ac3dec.h:245
const VDPAUPixFmtMap * map
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:522
int eac3
indicates if current frame is E-AC-3
Definition: ac3dec.h:99
int channel_uses_aht[AC3_MAX_CHANNELS]
channel AHT in use (chahtinu)
Definition: ac3dec.h:157
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:296
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
Definition: frame.h:521
int av_get_channel_layout_channel_index(uint64_t channel_layout, uint64_t channel)
Get the index of a channel in channel_layout.
uint8_t dba_lengths[AC3_MAX_CHANNELS][8]
delta segment lengths
Definition: ac3dec.h:212
static int coupling_coordinates(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:1021
static int ac3_parse_header(AC3DecodeContext *s)
Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
Definition: ac3dec.c:234
int prev_output_mode
output channel configuration for previous frame
Definition: ac3dec.h:168
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
AVFixedDSPContext * avpriv_alloc_fixed_dsp(int bit_exact)
Allocate and initialize a fixed DSP context.
Definition: fixed_dsp.c:148
int cpl_in_use[AC3_MAX_BLOCKS]
coupling in use (cplinu)
Definition: ac3dec.h:126
#define AC3_DYNAMIC_RANGE(x)
Definition: ac3.h:92
int dba_mode[AC3_MAX_CHANNELS]
delta bit allocation mode
Definition: ac3dec.h:209
const uint64_t ff_eac3_custom_channel_map_locations[16][2]
Definition: ac3tab.c:317
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int first_cpl_leak
first coupling leak state (firstcplleak)
Definition: ac3dec.h:202
int prev_bit_rate
stream bit rate, in bits-per-second for previous frame
Definition: ac3dec.h:170
int surround_mix_level
Surround mix level index.
Definition: ac3dec.h:95
int snr_offset[AC3_MAX_CHANNELS]
signal-to-noise ratio offsets (snroffst)
Definition: ac3dec.h:203
int downmixed
indicates if coeffs are currently downmixed
Definition: ac3dec.h:166
int
const uint8_t ff_ac3_channels_tab[8]
Map audio coding mode (acmod) to number of full-bandwidth channels.
Definition: ac3tab.c:82
common internal api header.
INTFLOAT * dlyptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:240
#define ff_mdct_end
Definition: fft.h:170
int surround_mix_level
Surround mix level index.
Definition: ac3.h:191
int num_blocks
number of audio blocks
Definition: ac3dec.h:83
#define AC3_OUTPUT_LFEON
Definition: ac3dec.h:63
FmtConvertContext fmt_conv
optimized conversion functions
Definition: ac3dec.h:235
int b1_mant[2]
Definition: ac3dec.c:501
int center_mix_level
Center mix level index.
Definition: ac3.h:190
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:142
static av_cold void ac3_tables_init(void)
Definition: ac3dec.c:123
int target_level
target level in dBFS
Definition: ac3dec.h:112
double center_mix_level
Absolute scale factor representing the nominal level of the center channel during a regular downmix...
Definition: downmix_info.h:68
int pre_mantissa[AC3_MAX_CHANNELS][AC3_MAX_COEFS][AC3_MAX_BLOCKS]
pre-IDCT mantissas
Definition: ac3dec.h:158
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1567
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
int rematrixing_flags[4]
rematrixing flags (rematflg)
Definition: ac3dec.h:191
int fixed_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
fixed-point transform coefficients
Definition: ac3dec.h:243
#define EAC3_MAX_CHANNELS
maximum number of channels in EAC3
Definition: ac3.h:31
uint8_t spx_band_sizes[SPX_MAX_BANDS]
number of bins in each spx band
Definition: ac3dec.h:150
int lfe_mix_level
LFE mix level index (lfemixlevcod)
Definition: ac3dec.h:98
#define AC3_SPX_BLEND(x)
Definition: ac3.h:93
static int parse_frame_header(AC3DecodeContext *s)
Common function to parse AC-3 or E-AC-3 frame header.
Definition: ac3dec.c:298
#define LEVEL_PLUS_3DB
Definition: ac3.h:104
int snr_offset_strategy
SNR offset strategy (snroffststr)
Definition: ac3dec.h:116
int b2_mant[2]
Definition: ac3dec.c:502
int start_freq[AC3_MAX_CHANNELS]
start frequency bin (strtmant)
Definition: ac3dec.h:181
int substreamid
substream identification
Definition: ac3.h:189
int channels
number of audio channels
Definition: avcodec.h:2197
int sample_rate
sample frequency, in Hz
Definition: ac3dec.h:82
int center_mix_level
Center mix level index.
Definition: ac3dec.h:93
uint8_t channels
Definition: ac3.h:203
int output_mode
output channel configuration
Definition: ac3dec.h:167
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
static const float gain_levels_lfe[32]
Adjustments in dB gain (LFE, +10 to -21 dB)
Definition: ac3dec.c:86
#define LEVEL_MINUS_6DB
Definition: ac3.h:109
int frame_size
current frame size, in bytes
Definition: ac3dec.h:80
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
#define av_freep(p)
static void ac3_upmix_delay(AC3DecodeContext *s)
Upmix delay samples from stereo to original channel layout.
Definition: ac3dec.c:725
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
signed 16 bits, planar
Definition: samplefmt.h:67
const uint8_t ff_eac3_hebap_tab[64]
Definition: ac3dec_data.c:46
int dolby_surround_ex_mode
dolby surround ex mode (dsurexmod)
Definition: ac3dec.h:103
#define av_malloc_array(a, b)
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
AVMatrixEncoding
int num_blocks
number of audio blocks
Definition: ac3.h:193
uint8_t channel_mode
Definition: ac3.h:186
AVLFG dith_state
for dither generation
Definition: ac3dec.h:218
int cpl_strategy_exists[AC3_MAX_BLOCKS]
coupling strategy exists (cplstre)
Definition: ac3dec.h:127
static av_cold int ac3_decode_init(AVCodecContext *avctx)
AVCodec initialization.
Definition: ac3dec.c:184
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:292
int bitstream_id
bitstream id (bsid)
Definition: ac3dec.h:84
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:273
#define AV_CH_LAYOUT_MONO
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:2254
static void remove_dithering(AC3DecodeContext *s)
Remove random dithering from coupling range coefficients with zero-bit mantissas for coupled channels...
Definition: ac3dec.c:594
This structure stores compressed data.
Definition: avcodec.h:1429
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:292
#define EXP_D45
Definition: ac3.h:53
int channel_mode
channel mode (acmod)
Definition: ac3dec.h:86
float ff_ac3_heavy_dynamic_range_tab[256]
Definition: ac3dec.c:69
for(j=16;j >0;--j)
int spx_dst_start_freq
spx starting frequency bin for copying (copystartmant) the copy region ends at the start of the spx r...
Definition: ac3dec.h:146
#define AC3_RENAME(x)
Definition: ac3.h:87
int skip_syntax
skip field syntax enabled (skipflde)
Definition: ac3dec.h:122
enum AVDownmixType preferred_downmix_type
Type of downmix preferred by the mastering engineer.
Definition: downmix_info.h:62
int b2
Definition: ac3dec.c:505
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
int8_t dexps[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
decoded exponents
Definition: ac3dec.h:196
#define MULH
Definition: mathops.h:42