FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules 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.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 /** dynamic range table. converts codes to scale factors. */
67 static float dynamic_range_tab[256];
68 static float heavy_dynamic_range_tab[256];
69 
70 /** Adjustments in dB gain */
71 static const float gain_levels[9] = {
74  LEVEL_ONE,
79  LEVEL_ZERO,
81 };
82 
83 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
84 static const float gain_levels_lfe[32] = {
85  3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
86  1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
87  0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
88  0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
89  0.125892, 0.112201, 0.100000, 0.089125
90 };
91 
92 /**
93  * Table for default stereo downmixing coefficients
94  * reference: Section 7.8.2 Downmixing Into Two Channels
95  */
96 static const uint8_t ac3_default_coeffs[8][5][2] = {
97  { { 2, 7 }, { 7, 2 }, },
98  { { 4, 4 }, },
99  { { 2, 7 }, { 7, 2 }, },
100  { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
101  { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
102  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
103  { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
104  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
105 };
106 
107 /**
108  * Symmetrical Dequantization
109  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
110  * Tables 7.19 to 7.23
111  */
112 static inline int
113 symmetric_dequant(int code, int levels)
114 {
115  return ((code - (levels >> 1)) * (1 << 24)) / levels;
116 }
117 
118 /*
119  * Initialize tables at runtime.
120  */
121 static av_cold void ac3_tables_init(void)
122 {
123  int i;
124 
125  /* generate table for ungrouping 3 values in 7 bits
126  reference: Section 7.1.3 Exponent Decoding */
127  for (i = 0; i < 128; i++) {
128  ungroup_3_in_7_bits_tab[i][0] = i / 25;
129  ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
130  ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
131  }
132 
133  /* generate grouped mantissa tables
134  reference: Section 7.3.5 Ungrouping of Mantissas */
135  for (i = 0; i < 32; i++) {
136  /* bap=1 mantissas */
140  }
141  for (i = 0; i < 128; i++) {
142  /* bap=2 mantissas */
146 
147  /* bap=4 mantissas */
148  b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
149  b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
150  }
151  /* generate ungrouped mantissa tables
152  reference: Tables 7.21 and 7.23 */
153  for (i = 0; i < 7; i++) {
154  /* bap=3 mantissas */
155  b3_mantissas[i] = symmetric_dequant(i, 7);
156  }
157  for (i = 0; i < 15; i++) {
158  /* bap=5 mantissas */
159  b5_mantissas[i] = symmetric_dequant(i, 15);
160  }
161 
162  /* generate dynamic range table
163  reference: Section 7.7.1 Dynamic Range Control */
164  for (i = 0; i < 256; i++) {
165  int v = (i >> 5) - ((i >> 7) << 3) - 5;
166  dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
167  }
168 
169  /* generate compr dynamic range table
170  reference: Section 7.7.2 Heavy Compression */
171  for (i = 0; i < 256; i++) {
172  int v = (i >> 4) - ((i >> 7) << 4) - 4;
173  heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
174  }
175 
176 }
177 
178 /**
179  * AVCodec initialization
180  */
182 {
183  AC3DecodeContext *s = avctx->priv_data;
184  int i;
185 
186  s->avctx = avctx;
187 
189  ac3_tables_init();
190  ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
191  ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
192  AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
193  ff_bswapdsp_init(&s->bdsp);
194 
195 #if (USE_FIXED)
197 #else
199  ff_fmt_convert_init(&s->fmt_conv, avctx);
200 #endif
201 
203  av_lfg_init(&s->dith_state, 0);
204 
205  if (USE_FIXED)
207  else
209 
210  /* allow downmixing to stereo or mono */
211 #if FF_API_REQUEST_CHANNELS
213  if (avctx->request_channels == 1)
215  else if (avctx->request_channels == 2)
218 #endif
219  if (avctx->channels > 1 &&
221  avctx->channels = 1;
222  else if (avctx->channels > 2 &&
224  avctx->channels = 2;
225  s->downmixed = 1;
226 
227  for (i = 0; i < AC3_MAX_CHANNELS; i++) {
228  s->xcfptr[i] = s->transform_coeffs[i];
229  s->dlyptr[i] = s->delay[i];
230  }
231 
232  return 0;
233 }
234 
235 /**
236  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
237  * GetBitContext within AC3DecodeContext must point to
238  * the start of the synchronized AC-3 bitstream.
239  */
241 {
242  GetBitContext *gbc = &s->gbc;
243  int i;
244 
245  /* read the rest of the bsi. read twice for dual mono mode. */
246  i = !s->channel_mode;
247  do {
248  s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
249  if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
250  s->dialog_normalization[(!s->channel_mode)-i] = -31;
251  }
252  if (s->target_level != 0) {
253  s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
254  (float)(s->target_level -
255  s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
256  }
257  if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
258  s->heavy_dynamic_range[(!s->channel_mode)-i] =
259  AC3_HEAVY_RANGE(get_bits(gbc, 8));
260  }
261  if (get_bits1(gbc))
262  skip_bits(gbc, 8); //skip language code
263  if (get_bits1(gbc))
264  skip_bits(gbc, 7); //skip audio production information
265  } while (i--);
266 
267  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
268 
269  /* skip the timecodes or parse the Alternate Bit Stream Syntax */
270  if (s->bitstream_id != 6) {
271  if (get_bits1(gbc))
272  skip_bits(gbc, 14); //skip timecode1
273  if (get_bits1(gbc))
274  skip_bits(gbc, 14); //skip timecode2
275  } else {
276  if (get_bits1(gbc)) {
277  s->preferred_downmix = get_bits(gbc, 2);
278  s->center_mix_level_ltrt = get_bits(gbc, 3);
279  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
280  s->center_mix_level = get_bits(gbc, 3);
281  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
282  }
283  if (get_bits1(gbc)) {
284  s->dolby_surround_ex_mode = get_bits(gbc, 2);
285  s->dolby_headphone_mode = get_bits(gbc, 2);
286  skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
287  }
288  }
289 
290  /* skip additional bitstream info */
291  if (get_bits1(gbc)) {
292  i = get_bits(gbc, 6);
293  do {
294  skip_bits(gbc, 8);
295  } while (i--);
296  }
297 
298  return 0;
299 }
300 
301 /**
302  * Common function to parse AC-3 or E-AC-3 frame header
303  */
305 {
306  AC3HeaderInfo hdr, *phdr=&hdr;
307  int err;
308 
309  err = avpriv_ac3_parse_header2(&s->gbc, &phdr);
310  if (err)
311  return err;
312 
313  /* get decoding parameters from header info */
315  s->bitstream_id = hdr.bitstream_id;
317  s->channel_mode = hdr.channel_mode;
318  s->lfe_on = hdr.lfe_on;
320  s->sample_rate = hdr.sample_rate;
321  s->bit_rate = hdr.bit_rate;
322  s->channels = hdr.channels;
323  s->fbw_channels = s->channels - s->lfe_on;
324  s->lfe_ch = s->fbw_channels + 1;
325  s->frame_size = hdr.frame_size;
328  s->center_mix_level_ltrt = 4; // -3.0dB
330  s->surround_mix_level_ltrt = 4; // -3.0dB
331  s->lfe_mix_level_exists = 0;
332  s->num_blocks = hdr.num_blocks;
333  s->frame_type = hdr.frame_type;
334  s->substreamid = hdr.substreamid;
338 
339  if (s->lfe_on) {
340  s->start_freq[s->lfe_ch] = 0;
341  s->end_freq[s->lfe_ch] = 7;
342  s->num_exp_groups[s->lfe_ch] = 2;
343  s->channel_in_cpl[s->lfe_ch] = 0;
344  }
345 
346  if (s->bitstream_id <= 10) {
347  s->eac3 = 0;
348  s->snr_offset_strategy = 2;
349  s->block_switch_syntax = 1;
350  s->dither_flag_syntax = 1;
351  s->bit_allocation_syntax = 1;
352  s->fast_gain_syntax = 0;
353  s->first_cpl_leak = 0;
354  s->dba_syntax = 1;
355  s->skip_syntax = 1;
356  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
357  return ac3_parse_header(s);
358  } else if (CONFIG_EAC3_DECODER) {
359  s->eac3 = 1;
360  return ff_eac3_parse_header(s);
361  } else {
362  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
363  return AVERROR(ENOSYS);
364  }
365 }
366 
367 /**
368  * Set stereo downmixing coefficients based on frame header info.
369  * reference: Section 7.8.2 Downmixing Into Two Channels
370  */
372 {
373  int i;
374  float cmix = gain_levels[s-> center_mix_level];
375  float smix = gain_levels[s->surround_mix_level];
376  float norm0, norm1;
377  float downmix_coeffs[AC3_MAX_CHANNELS][2];
378 
379  for (i = 0; i < s->fbw_channels; i++) {
380  downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
381  downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
382  }
383  if (s->channel_mode > 1 && s->channel_mode & 1) {
384  downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
385  }
387  int nf = s->channel_mode - 2;
388  downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
389  }
391  int nf = s->channel_mode - 4;
392  downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
393  }
394 
395  /* renormalize */
396  norm0 = norm1 = 0.0;
397  for (i = 0; i < s->fbw_channels; i++) {
398  norm0 += downmix_coeffs[i][0];
399  norm1 += downmix_coeffs[i][1];
400  }
401  norm0 = 1.0f / norm0;
402  norm1 = 1.0f / norm1;
403  for (i = 0; i < s->fbw_channels; i++) {
404  downmix_coeffs[i][0] *= norm0;
405  downmix_coeffs[i][1] *= norm1;
406  }
407 
408  if (s->output_mode == AC3_CHMODE_MONO) {
409  for (i = 0; i < s->fbw_channels; i++)
410  downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
411  downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
412  }
413  for (i = 0; i < s->fbw_channels; i++) {
414  s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
415  s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
416  }
417 }
418 
419 /**
420  * Decode the grouped exponents according to exponent strategy.
421  * reference: Section 7.1.3 Exponent Decoding
422  */
423 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
424  uint8_t absexp, int8_t *dexps)
425 {
426  int i, j, grp, group_size;
427  int dexp[256];
428  int expacc, prevexp;
429 
430  /* unpack groups */
431  group_size = exp_strategy + (exp_strategy == EXP_D45);
432  for (grp = 0, i = 0; grp < ngrps; grp++) {
433  expacc = get_bits(gbc, 7);
434  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
435  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
436  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
437  }
438 
439  /* convert to absolute exps and expand groups */
440  prevexp = absexp;
441  for (i = 0, j = 0; i < ngrps * 3; i++) {
442  prevexp += dexp[i] - 2;
443  if (prevexp > 24U)
444  return -1;
445  switch (group_size) {
446  case 4: dexps[j++] = prevexp;
447  dexps[j++] = prevexp;
448  case 2: dexps[j++] = prevexp;
449  case 1: dexps[j++] = prevexp;
450  }
451  }
452  return 0;
453 }
454 
455 /**
456  * Generate transform coefficients for each coupled channel in the coupling
457  * range using the coupling coefficients and coupling coordinates.
458  * reference: Section 7.4.3 Coupling Coordinate Format
459  */
461 {
462  int bin, band, ch;
463 
464  bin = s->start_freq[CPL_CH];
465  for (band = 0; band < s->num_cpl_bands; band++) {
466  int band_start = bin;
467  int band_end = bin + s->cpl_band_sizes[band];
468  for (ch = 1; ch <= s->fbw_channels; ch++) {
469  if (s->channel_in_cpl[ch]) {
470  int cpl_coord = s->cpl_coords[ch][band] << 5;
471  for (bin = band_start; bin < band_end; bin++) {
472  s->fixed_coeffs[ch][bin] =
473  MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
474  }
475  if (ch == 2 && s->phase_flags[band]) {
476  for (bin = band_start; bin < band_end; bin++)
477  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
478  }
479  }
480  }
481  bin = band_end;
482  }
483 }
484 
485 /**
486  * Grouped mantissas for 3-level 5-level and 11-level quantization
487  */
488 typedef struct mant_groups {
489  int b1_mant[2];
490  int b2_mant[2];
491  int b4_mant;
492  int b1;
493  int b2;
494  int b4;
495 } mant_groups;
496 
497 /**
498  * Decode the transform coefficients for a particular channel
499  * reference: Section 7.3 Quantization and Decoding of Mantissas
500  */
502 {
503  int start_freq = s->start_freq[ch_index];
504  int end_freq = s->end_freq[ch_index];
505  uint8_t *baps = s->bap[ch_index];
506  int8_t *exps = s->dexps[ch_index];
507  int32_t *coeffs = s->fixed_coeffs[ch_index];
508  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
509  GetBitContext *gbc = &s->gbc;
510  int freq;
511 
512  for (freq = start_freq; freq < end_freq; freq++) {
513  int bap = baps[freq];
514  int mantissa;
515  switch (bap) {
516  case 0:
517  /* random noise with approximate range of -0.707 to 0.707 */
518  if (dither)
519  mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
520  else
521  mantissa = 0;
522  break;
523  case 1:
524  if (m->b1) {
525  m->b1--;
526  mantissa = m->b1_mant[m->b1];
527  } else {
528  int bits = get_bits(gbc, 5);
529  mantissa = b1_mantissas[bits][0];
530  m->b1_mant[1] = b1_mantissas[bits][1];
531  m->b1_mant[0] = b1_mantissas[bits][2];
532  m->b1 = 2;
533  }
534  break;
535  case 2:
536  if (m->b2) {
537  m->b2--;
538  mantissa = m->b2_mant[m->b2];
539  } else {
540  int bits = get_bits(gbc, 7);
541  mantissa = b2_mantissas[bits][0];
542  m->b2_mant[1] = b2_mantissas[bits][1];
543  m->b2_mant[0] = b2_mantissas[bits][2];
544  m->b2 = 2;
545  }
546  break;
547  case 3:
548  mantissa = b3_mantissas[get_bits(gbc, 3)];
549  break;
550  case 4:
551  if (m->b4) {
552  m->b4 = 0;
553  mantissa = m->b4_mant;
554  } else {
555  int bits = get_bits(gbc, 7);
556  mantissa = b4_mantissas[bits][0];
557  m->b4_mant = b4_mantissas[bits][1];
558  m->b4 = 1;
559  }
560  break;
561  case 5:
562  mantissa = b5_mantissas[get_bits(gbc, 4)];
563  break;
564  default: /* 6 to 15 */
565  /* Shift mantissa and sign-extend it. */
566  if (bap > 15) {
567  av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
568  bap = 15;
569  }
570  mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
571  break;
572  }
573  coeffs[freq] = mantissa >> exps[freq];
574  }
575 }
576 
577 /**
578  * Remove random dithering from coupling range coefficients with zero-bit
579  * mantissas for coupled channels which do not use dithering.
580  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
581  */
583  int ch, i;
584 
585  for (ch = 1; ch <= s->fbw_channels; ch++) {
586  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
587  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
588  if (!s->bap[CPL_CH][i])
589  s->fixed_coeffs[ch][i] = 0;
590  }
591  }
592  }
593 }
594 
596  mant_groups *m)
597 {
598  if (!s->channel_uses_aht[ch]) {
600  } else {
601  /* if AHT is used, mantissas for all blocks are encoded in the first
602  block of the frame. */
603  int bin;
604  if (CONFIG_EAC3_DECODER && !blk)
606  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
607  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
608  }
609  }
610 }
611 
612 /**
613  * Decode the transform coefficients.
614  */
616 {
617  int ch, end;
618  int got_cplchan = 0;
619  mant_groups m;
620 
621  m.b1 = m.b2 = m.b4 = 0;
622 
623  for (ch = 1; ch <= s->channels; ch++) {
624  /* transform coefficients for full-bandwidth channel */
625  decode_transform_coeffs_ch(s, blk, ch, &m);
626  /* transform coefficients for coupling channel come right after the
627  coefficients for the first coupled channel*/
628  if (s->channel_in_cpl[ch]) {
629  if (!got_cplchan) {
630  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
632  got_cplchan = 1;
633  }
634  end = s->end_freq[CPL_CH];
635  } else {
636  end = s->end_freq[ch];
637  }
638  do
639  s->fixed_coeffs[ch][end] = 0;
640  while (++end < 256);
641  }
642 
643  /* zero the dithered coefficients for appropriate channels */
644  remove_dithering(s);
645 }
646 
647 /**
648  * Stereo rematrixing.
649  * reference: Section 7.5.4 Rematrixing : Decoding Technique
650  */
652 {
653  int bnd, i;
654  int end, bndend;
655 
656  end = FFMIN(s->end_freq[1], s->end_freq[2]);
657 
658  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
659  if (s->rematrixing_flags[bnd]) {
660  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
661  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
662  int tmp0 = s->fixed_coeffs[1][i];
663  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
664  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
665  }
666  }
667  }
668 }
669 
670 /**
671  * Inverse MDCT Transform.
672  * Convert frequency domain coefficients to time-domain audio samples.
673  * reference: Section 7.9.4 Transformation Equations
674  */
675 static inline void do_imdct(AC3DecodeContext *s, int channels)
676 {
677  int ch;
678 
679  for (ch = 1; ch <= channels; ch++) {
680  if (s->block_switch[ch]) {
681  int i;
682  FFTSample *x = s->tmp_output + 128;
683  for (i = 0; i < 128; i++)
684  x[i] = s->transform_coeffs[ch][2 * i];
685  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
686 #if USE_FIXED
687  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
688  s->tmp_output, s->window, 128, 8);
689 #else
690  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
691  s->tmp_output, s->window, 128);
692 #endif
693  for (i = 0; i < 128; i++)
694  x[i] = s->transform_coeffs[ch][2 * i + 1];
695  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
696  } else {
698 #if USE_FIXED
699  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
700  s->tmp_output, s->window, 128, 8);
701 #else
702  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
703  s->tmp_output, s->window, 128);
704 #endif
705  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
706  }
707  }
708 }
709 
710 /**
711  * Upmix delay samples from stereo to original channel layout.
712  */
714 {
715  int channel_data_size = sizeof(s->delay[0]);
716  switch (s->channel_mode) {
717  case AC3_CHMODE_DUALMONO:
718  case AC3_CHMODE_STEREO:
719  /* upmix mono to stereo */
720  memcpy(s->delay[1], s->delay[0], channel_data_size);
721  break;
722  case AC3_CHMODE_2F2R:
723  memset(s->delay[3], 0, channel_data_size);
724  case AC3_CHMODE_2F1R:
725  memset(s->delay[2], 0, channel_data_size);
726  break;
727  case AC3_CHMODE_3F2R:
728  memset(s->delay[4], 0, channel_data_size);
729  case AC3_CHMODE_3F1R:
730  memset(s->delay[3], 0, channel_data_size);
731  case AC3_CHMODE_3F:
732  memcpy(s->delay[2], s->delay[1], channel_data_size);
733  memset(s->delay[1], 0, channel_data_size);
734  break;
735  }
736 }
737 
738 /**
739  * Decode band structure for coupling, spectral extension, or enhanced coupling.
740  * The band structure defines how many subbands are in each band. For each
741  * subband in the range, 1 means it is combined with the previous band, and 0
742  * means that it starts a new band.
743  *
744  * @param[in] gbc bit reader context
745  * @param[in] blk block number
746  * @param[in] eac3 flag to indicate E-AC-3
747  * @param[in] ecpl flag to indicate enhanced coupling
748  * @param[in] start_subband subband number for start of range
749  * @param[in] end_subband subband number for end of range
750  * @param[in] default_band_struct default band structure table
751  * @param[out] num_bands number of bands (optionally NULL)
752  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
753  * @param[in,out] band_struct current band structure
754  */
755 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
756  int ecpl, int start_subband, int end_subband,
757  const uint8_t *default_band_struct,
758  int *num_bands, uint8_t *band_sizes,
759  uint8_t *band_struct, int band_struct_size)
760 {
761  int subbnd, bnd, n_subbands, n_bands=0;
762  uint8_t bnd_sz[22];
763 
764  n_subbands = end_subband - start_subband;
765 
766  if (!blk)
767  memcpy(band_struct, default_band_struct, band_struct_size);
768 
769  av_assert0(band_struct_size >= start_subband + n_subbands);
770 
771  band_struct += start_subband + 1;
772 
773  /* decode band structure from bitstream or use default */
774  if (!eac3 || get_bits1(gbc)) {
775  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
776  band_struct[subbnd] = get_bits1(gbc);
777  }
778  }
779 
780  /* calculate number of bands and band sizes based on band structure.
781  note that the first 4 subbands in enhanced coupling span only 6 bins
782  instead of 12. */
783  if (num_bands || band_sizes ) {
784  n_bands = n_subbands;
785  bnd_sz[0] = ecpl ? 6 : 12;
786  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
787  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
788  if (band_struct[subbnd - 1]) {
789  n_bands--;
790  bnd_sz[bnd] += subbnd_size;
791  } else {
792  bnd_sz[++bnd] = subbnd_size;
793  }
794  }
795  }
796 
797  /* set optional output params */
798  if (num_bands)
799  *num_bands = n_bands;
800  if (band_sizes)
801  memcpy(band_sizes, bnd_sz, n_bands);
802 }
803 
804 /**
805  * Decode a single audio block from the AC-3 bitstream.
806  */
808 {
809  int fbw_channels = s->fbw_channels;
810  int channel_mode = s->channel_mode;
811  int i, bnd, seg, ch;
812  int different_transforms;
813  int downmix_output;
814  int cpl_in_use;
815  GetBitContext *gbc = &s->gbc;
816  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
817 
818  /* block switch flags */
819  different_transforms = 0;
820  if (s->block_switch_syntax) {
821  for (ch = 1; ch <= fbw_channels; ch++) {
822  s->block_switch[ch] = get_bits1(gbc);
823  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
824  different_transforms = 1;
825  }
826  }
827 
828  /* dithering flags */
829  if (s->dither_flag_syntax) {
830  for (ch = 1; ch <= fbw_channels; ch++) {
831  s->dither_flag[ch] = get_bits1(gbc);
832  }
833  }
834 
835  /* dynamic range */
836  i = !s->channel_mode;
837  do {
838  if (get_bits1(gbc)) {
839  /* Allow asymmetric application of DRC when drc_scale > 1.
840  Amplification of quiet sounds is enhanced */
841  int range_bits = get_bits(gbc, 8);
842  INTFLOAT range = AC3_RANGE(range_bits);
843  if (range_bits <= 127 || s->drc_scale <= 1.0)
844  s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
845  else
846  s->dynamic_range[i] = range;
847  } else if (blk == 0) {
849  }
850  } while (i--);
851 
852  /* spectral extension strategy */
853  if (s->eac3 && (!blk || get_bits1(gbc))) {
854  s->spx_in_use = get_bits1(gbc);
855  if (s->spx_in_use) {
856  int dst_start_freq, dst_end_freq, src_start_freq,
857  start_subband, end_subband;
858 
859  /* determine which channels use spx */
860  if (s->channel_mode == AC3_CHMODE_MONO) {
861  s->channel_uses_spx[1] = 1;
862  } else {
863  for (ch = 1; ch <= fbw_channels; ch++)
864  s->channel_uses_spx[ch] = get_bits1(gbc);
865  }
866 
867  /* get the frequency bins of the spx copy region and the spx start
868  and end subbands */
869  dst_start_freq = get_bits(gbc, 2);
870  start_subband = get_bits(gbc, 3) + 2;
871  if (start_subband > 7)
872  start_subband += start_subband - 7;
873  end_subband = get_bits(gbc, 3) + 5;
874 #if USE_FIXED
875  s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
876 #endif
877  if (end_subband > 7)
878  end_subband += end_subband - 7;
879  dst_start_freq = dst_start_freq * 12 + 25;
880  src_start_freq = start_subband * 12 + 25;
881  dst_end_freq = end_subband * 12 + 25;
882 
883  /* check validity of spx ranges */
884  if (start_subband >= end_subband) {
885  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
886  "range (%d >= %d)\n", start_subband, end_subband);
887  return AVERROR_INVALIDDATA;
888  }
889  if (dst_start_freq >= src_start_freq) {
890  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
891  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
892  return AVERROR_INVALIDDATA;
893  }
894 
895  s->spx_dst_start_freq = dst_start_freq;
896  s->spx_src_start_freq = src_start_freq;
897  if (!USE_FIXED)
898  s->spx_dst_end_freq = dst_end_freq;
899 
900  decode_band_structure(gbc, blk, s->eac3, 0,
901  start_subband, end_subband,
903  &s->num_spx_bands,
904  s->spx_band_sizes,
905  s->spx_band_struct, sizeof(s->spx_band_struct));
906  }
907  }
908  if (!s->eac3 || !s->spx_in_use) {
909  s->spx_in_use = 0;
910  for (ch = 1; ch <= fbw_channels; ch++) {
911  s->channel_uses_spx[ch] = 0;
912  s->first_spx_coords[ch] = 1;
913  }
914  }
915 
916  /* spectral extension coordinates */
917  if (s->spx_in_use) {
918  for (ch = 1; ch <= fbw_channels; ch++) {
919  if (s->channel_uses_spx[ch]) {
920  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
921  INTFLOAT spx_blend;
922  int bin, master_spx_coord;
923 
924  s->first_spx_coords[ch] = 0;
925  spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
926  master_spx_coord = get_bits(gbc, 2) * 3;
927 
928  bin = s->spx_src_start_freq;
929  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
930  int bandsize = s->spx_band_sizes[bnd];
931  int spx_coord_exp, spx_coord_mant;
932  INTFLOAT nratio, sblend, nblend;
933 #if USE_FIXED
934  /* calculate blending factors */
935  int64_t accu = ((bin << 23) + (bandsize << 22))
936  * (int64_t)s->spx_dst_end_freq;
937  nratio = (int)(accu >> 32);
938  nratio -= spx_blend << 18;
939 
940  if (nratio < 0) {
941  nblend = 0;
942  sblend = 0x800000;
943  } else if (nratio > 0x7fffff) {
944  nblend = 14529495; // sqrt(3) in FP.23
945  sblend = 0;
946  } else {
947  nblend = fixed_sqrt(nratio, 23);
948  accu = (int64_t)nblend * 1859775393;
949  nblend = (int)((accu + (1<<29)) >> 30);
950  sblend = fixed_sqrt(0x800000 - nratio, 23);
951  }
952 #else
953  float spx_coord;
954 
955  /* calculate blending factors */
956  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
957  nratio = av_clipf(nratio, 0.0f, 1.0f);
958  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
959  // to give unity variance
960  sblend = sqrtf(1.0f - nratio);
961 #endif
962  bin += bandsize;
963 
964  /* decode spx coordinates */
965  spx_coord_exp = get_bits(gbc, 4);
966  spx_coord_mant = get_bits(gbc, 2);
967  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
968  else spx_coord_mant += 4;
969  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
970 
971  /* multiply noise and signal blending factors by spx coordinate */
972 #if USE_FIXED
973  accu = (int64_t)nblend * spx_coord_mant;
974  s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
975  accu = (int64_t)sblend * spx_coord_mant;
976  s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
977 #else
978  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
979  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
980  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
981 #endif
982  }
983  }
984  } else {
985  s->first_spx_coords[ch] = 1;
986  }
987  }
988  }
989 
990  /* coupling strategy */
991  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
992  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
993  if (!s->eac3)
994  s->cpl_in_use[blk] = get_bits1(gbc);
995  if (s->cpl_in_use[blk]) {
996  /* coupling in use */
997  int cpl_start_subband, cpl_end_subband;
998 
999  if (channel_mode < AC3_CHMODE_STEREO) {
1000  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
1001  return AVERROR_INVALIDDATA;
1002  }
1003 
1004  /* check for enhanced coupling */
1005  if (s->eac3 && get_bits1(gbc)) {
1006  /* TODO: parse enhanced coupling strategy info */
1007  avpriv_request_sample(s->avctx, "Enhanced coupling");
1008  return AVERROR_PATCHWELCOME;
1009  }
1010 
1011  /* determine which channels are coupled */
1012  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
1013  s->channel_in_cpl[1] = 1;
1014  s->channel_in_cpl[2] = 1;
1015  } else {
1016  for (ch = 1; ch <= fbw_channels; ch++)
1017  s->channel_in_cpl[ch] = get_bits1(gbc);
1018  }
1019 
1020  /* phase flags in use */
1021  if (channel_mode == AC3_CHMODE_STEREO)
1022  s->phase_flags_in_use = get_bits1(gbc);
1023 
1024  /* coupling frequency range */
1025  cpl_start_subband = get_bits(gbc, 4);
1026  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1027  get_bits(gbc, 4) + 3;
1028  if (cpl_start_subband >= cpl_end_subband) {
1029  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1030  cpl_start_subband, cpl_end_subband);
1031  return AVERROR_INVALIDDATA;
1032  }
1033  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1034  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1035 
1036  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1037  cpl_end_subband,
1039  &s->num_cpl_bands, s->cpl_band_sizes,
1040  s->cpl_band_struct, sizeof(s->cpl_band_struct));
1041  } else {
1042  /* coupling not in use */
1043  for (ch = 1; ch <= fbw_channels; ch++) {
1044  s->channel_in_cpl[ch] = 0;
1045  s->first_cpl_coords[ch] = 1;
1046  }
1047  s->first_cpl_leak = s->eac3;
1048  s->phase_flags_in_use = 0;
1049  }
1050  } else if (!s->eac3) {
1051  if (!blk) {
1052  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1053  "be present in block 0\n");
1054  return AVERROR_INVALIDDATA;
1055  } else {
1056  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1057  }
1058  }
1059  cpl_in_use = s->cpl_in_use[blk];
1060 
1061  /* coupling coordinates */
1062  if (cpl_in_use) {
1063  int cpl_coords_exist = 0;
1064 
1065  for (ch = 1; ch <= fbw_channels; ch++) {
1066  if (s->channel_in_cpl[ch]) {
1067  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1068  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1069  s->first_cpl_coords[ch] = 0;
1070  cpl_coords_exist = 1;
1071  master_cpl_coord = 3 * get_bits(gbc, 2);
1072  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1073  cpl_coord_exp = get_bits(gbc, 4);
1074  cpl_coord_mant = get_bits(gbc, 4);
1075  if (cpl_coord_exp == 15)
1076  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1077  else
1078  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1079  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1080  }
1081  } else if (!blk) {
1082  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1083  "be present in block 0\n");
1084  return AVERROR_INVALIDDATA;
1085  }
1086  } else {
1087  /* channel not in coupling */
1088  s->first_cpl_coords[ch] = 1;
1089  }
1090  }
1091  /* phase flags */
1092  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1093  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1094  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1095  }
1096  }
1097  }
1098 
1099  /* stereo rematrixing strategy and band structure */
1100  if (channel_mode == AC3_CHMODE_STEREO) {
1101  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1102  s->num_rematrixing_bands = 4;
1103  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1104  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1105  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1106  s->num_rematrixing_bands--;
1107  }
1108  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1109  s->rematrixing_flags[bnd] = get_bits1(gbc);
1110  } else if (!blk) {
1111  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1112  "new rematrixing strategy not present in block 0\n");
1113  s->num_rematrixing_bands = 0;
1114  }
1115  }
1116 
1117  /* exponent strategies for each channel */
1118  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1119  if (!s->eac3)
1120  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1121  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1122  bit_alloc_stages[ch] = 3;
1123  }
1124 
1125  /* channel bandwidth */
1126  for (ch = 1; ch <= fbw_channels; ch++) {
1127  s->start_freq[ch] = 0;
1128  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1129  int group_size;
1130  int prev = s->end_freq[ch];
1131  if (s->channel_in_cpl[ch])
1132  s->end_freq[ch] = s->start_freq[CPL_CH];
1133  else if (s->channel_uses_spx[ch])
1134  s->end_freq[ch] = s->spx_src_start_freq;
1135  else {
1136  int bandwidth_code = get_bits(gbc, 6);
1137  if (bandwidth_code > 60) {
1138  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1139  return AVERROR_INVALIDDATA;
1140  }
1141  s->end_freq[ch] = bandwidth_code * 3 + 73;
1142  }
1143  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1144  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1145  if (blk > 0 && s->end_freq[ch] != prev)
1146  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1147  }
1148  }
1149  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1151  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1152  }
1153 
1154  /* decode exponents for each channel */
1155  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1156  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1157  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1158  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1159  s->num_exp_groups[ch], s->dexps[ch][0],
1160  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1161  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1162  return AVERROR_INVALIDDATA;
1163  }
1164  if (ch != CPL_CH && ch != s->lfe_ch)
1165  skip_bits(gbc, 2); /* skip gainrng */
1166  }
1167  }
1168 
1169  /* bit allocation information */
1170  if (s->bit_allocation_syntax) {
1171  if (get_bits1(gbc)) {
1177  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1178  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1179  } else if (!blk) {
1180  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1181  "be present in block 0\n");
1182  return AVERROR_INVALIDDATA;
1183  }
1184  }
1185 
1186  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1187  if (!s->eac3 || !blk) {
1188  if (s->snr_offset_strategy && get_bits1(gbc)) {
1189  int snr = 0;
1190  int csnr;
1191  csnr = (get_bits(gbc, 6) - 15) << 4;
1192  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1193  /* snr offset */
1194  if (ch == i || s->snr_offset_strategy == 2)
1195  snr = (csnr + get_bits(gbc, 4)) << 2;
1196  /* run at least last bit allocation stage if snr offset changes */
1197  if (blk && s->snr_offset[ch] != snr) {
1198  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1199  }
1200  s->snr_offset[ch] = snr;
1201 
1202  /* fast gain (normal AC-3 only) */
1203  if (!s->eac3) {
1204  int prev = s->fast_gain[ch];
1205  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1206  /* run last 2 bit allocation stages if fast gain changes */
1207  if (blk && prev != s->fast_gain[ch])
1208  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1209  }
1210  }
1211  } else if (!s->eac3 && !blk) {
1212  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1213  return AVERROR_INVALIDDATA;
1214  }
1215  }
1216 
1217  /* fast gain (E-AC-3 only) */
1218  if (s->fast_gain_syntax && get_bits1(gbc)) {
1219  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1220  int prev = s->fast_gain[ch];
1221  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1222  /* run last 2 bit allocation stages if fast gain changes */
1223  if (blk && prev != s->fast_gain[ch])
1224  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1225  }
1226  } else if (s->eac3 && !blk) {
1227  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1228  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1229  }
1230 
1231  /* E-AC-3 to AC-3 converter SNR offset */
1232  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1233  skip_bits(gbc, 10); // skip converter snr offset
1234  }
1235 
1236  /* coupling leak information */
1237  if (cpl_in_use) {
1238  if (s->first_cpl_leak || get_bits1(gbc)) {
1239  int fl = get_bits(gbc, 3);
1240  int sl = get_bits(gbc, 3);
1241  /* run last 2 bit allocation stages for coupling channel if
1242  coupling leak changes */
1243  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1244  sl != s->bit_alloc_params.cpl_slow_leak)) {
1245  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1246  }
1249  } else if (!s->eac3 && !blk) {
1250  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1251  "be present in block 0\n");
1252  return AVERROR_INVALIDDATA;
1253  }
1254  s->first_cpl_leak = 0;
1255  }
1256 
1257  /* delta bit allocation information */
1258  if (s->dba_syntax && get_bits1(gbc)) {
1259  /* delta bit allocation exists (strategy) */
1260  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1261  s->dba_mode[ch] = get_bits(gbc, 2);
1262  if (s->dba_mode[ch] == DBA_RESERVED) {
1263  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1264  return AVERROR_INVALIDDATA;
1265  }
1266  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1267  }
1268  /* channel delta offset, len and bit allocation */
1269  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1270  if (s->dba_mode[ch] == DBA_NEW) {
1271  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1272  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1273  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1274  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1275  s->dba_values[ch][seg] = get_bits(gbc, 3);
1276  }
1277  /* run last 2 bit allocation stages if new dba values */
1278  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1279  }
1280  }
1281  } else if (blk == 0) {
1282  for (ch = 0; ch <= s->channels; ch++) {
1283  s->dba_mode[ch] = DBA_NONE;
1284  }
1285  }
1286 
1287  /* Bit allocation */
1288  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1289  if (bit_alloc_stages[ch] > 2) {
1290  /* Exponent mapping into PSD and PSD integration */
1292  s->start_freq[ch], s->end_freq[ch],
1293  s->psd[ch], s->band_psd[ch]);
1294  }
1295  if (bit_alloc_stages[ch] > 1) {
1296  /* Compute excitation function, Compute masking curve, and
1297  Apply delta bit allocation */
1299  s->start_freq[ch], s->end_freq[ch],
1300  s->fast_gain[ch], (ch == s->lfe_ch),
1301  s->dba_mode[ch], s->dba_nsegs[ch],
1302  s->dba_offsets[ch], s->dba_lengths[ch],
1303  s->dba_values[ch], s->mask[ch])) {
1304  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1305  return AVERROR_INVALIDDATA;
1306  }
1307  }
1308  if (bit_alloc_stages[ch] > 0) {
1309  /* Compute bit allocation */
1310  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1312  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1313  s->start_freq[ch], s->end_freq[ch],
1314  s->snr_offset[ch],
1316  bap_tab, s->bap[ch]);
1317  }
1318  }
1319 
1320  /* unused dummy data */
1321  if (s->skip_syntax && get_bits1(gbc)) {
1322  int skipl = get_bits(gbc, 9);
1323  while (skipl--)
1324  skip_bits(gbc, 8);
1325  }
1326 
1327  /* unpack the transform coefficients
1328  this also uncouples channels if coupling is in use. */
1329  decode_transform_coeffs(s, blk);
1330 
1331  /* TODO: generate enhanced coupling coordinates and uncouple */
1332 
1333  /* recover coefficients if rematrixing is in use */
1334  if (s->channel_mode == AC3_CHMODE_STEREO)
1335  do_rematrixing(s);
1336 
1337  /* apply scaling to coefficients (headroom, dynrng) */
1338  for (ch = 1; ch <= s->channels; ch++) {
1339  int audio_channel = 0;
1340  INTFLOAT gain;
1341  if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1342  audio_channel = 2-ch;
1343  if (s->heavy_compression && s->compression_exists[audio_channel])
1344  gain = s->heavy_dynamic_range[audio_channel];
1345  else
1346  gain = s->dynamic_range[audio_channel];
1347 
1348 #if USE_FIXED
1349  scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1350 #else
1351  if (s->target_level != 0)
1352  gain = gain * s->level_gain[audio_channel];
1353  gain *= 1.0 / 4194304.0f;
1355  s->fixed_coeffs[ch], gain, 256);
1356 #endif
1357  }
1358 
1359  /* apply spectral extension to high frequency bins */
1360  if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1362  }
1363 
1364  /* downmix and MDCT. order depends on whether block switching is used for
1365  any channel in this block. this is because coefficients for the long
1366  and short transforms cannot be mixed. */
1367  downmix_output = s->channels != s->out_channels &&
1368  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1369  s->fbw_channels == s->out_channels);
1370  if (different_transforms) {
1371  /* the delay samples have already been downmixed, so we upmix the delay
1372  samples in order to reconstruct all channels before downmixing. */
1373  if (s->downmixed) {
1374  s->downmixed = 0;
1375  ac3_upmix_delay(s);
1376  }
1377 
1378  do_imdct(s, s->channels);
1379 
1380  if (downmix_output) {
1381 #if USE_FIXED
1383  s->out_channels, s->fbw_channels, 256);
1384 #else
1385  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1386  s->out_channels, s->fbw_channels, 256);
1387 #endif
1388  }
1389  } else {
1390  if (downmix_output) {
1391  s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1392  s->out_channels, s->fbw_channels, 256);
1393  }
1394 
1395  if (downmix_output && !s->downmixed) {
1396  s->downmixed = 1;
1397  s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1398  s->out_channels, s->fbw_channels, 128);
1399  }
1400 
1401  do_imdct(s, s->out_channels);
1402  }
1403 
1404  return 0;
1405 }
1406 
1407 /**
1408  * Decode a single AC-3 frame.
1409  */
1410 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1411  int *got_frame_ptr, AVPacket *avpkt)
1412 {
1413  AVFrame *frame = data;
1414  const uint8_t *buf = avpkt->data;
1415  int buf_size = avpkt->size;
1416  AC3DecodeContext *s = avctx->priv_data;
1417  int blk, ch, err, ret;
1418  const uint8_t *channel_map;
1419  const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1420  enum AVMatrixEncoding matrix_encoding;
1421  AVDownmixInfo *downmix_info;
1422 
1423  /* copy input buffer to decoder context to avoid reading past the end
1424  of the buffer, which can be caused by a damaged input stream. */
1425  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1426  // seems to be byte-swapped AC-3
1427  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1428  s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1429  (const uint16_t *) buf, cnt);
1430  } else
1431  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1432  buf = s->input_buffer;
1433  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1434  if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1435  return ret;
1436 
1437  /* parse the syncinfo */
1438  err = parse_frame_header(s);
1439 
1440  if (err) {
1441  switch (err) {
1443  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1444  return AVERROR_INVALIDDATA;
1446  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1447  break;
1449  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1450  break;
1452  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1453  break;
1455  /* skip frame if CRC is ok. otherwise use error concealment. */
1456  /* TODO: add support for substreams and dependent frames */
1458  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1459  "skipping frame\n");
1460  *got_frame_ptr = 0;
1461  return buf_size;
1462  } else {
1463  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1464  }
1465  break;
1468  break;
1469  default: // Normal AVERROR do not try to recover.
1470  *got_frame_ptr = 0;
1471  return err;
1472  }
1473  } else {
1474  /* check that reported frame size fits in input buffer */
1475  if (s->frame_size > buf_size) {
1476  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1478  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1479  /* check for crc mismatch */
1480  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1481  s->frame_size - 2)) {
1482  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1483  if (avctx->err_recognition & AV_EF_EXPLODE)
1484  return AVERROR_INVALIDDATA;
1486  }
1487  }
1488  }
1489 
1490  /* if frame is ok, set audio parameters */
1491  if (!err) {
1492  avctx->sample_rate = s->sample_rate;
1493  avctx->bit_rate = s->bit_rate;
1494  }
1495 
1496  /* channel config */
1497  if (!err || (s->channels && s->out_channels != s->channels)) {
1498  s->out_channels = s->channels;
1499  s->output_mode = s->channel_mode;
1500  if (s->lfe_on)
1502  if (s->channels > 1 &&
1504  s->out_channels = 1;
1506  } else if (s->channels > 2 &&
1508  s->out_channels = 2;
1510  }
1511 
1512  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1516  /* set downmixing coefficients if needed */
1517  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1518  s->fbw_channels == s->out_channels)) {
1519  set_downmix_coeffs(s);
1520  }
1521  } else if (!s->channels) {
1522  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1523  return AVERROR_INVALIDDATA;
1524  }
1525  avctx->channels = s->out_channels;
1527  if (s->output_mode & AC3_OUTPUT_LFEON)
1529 
1530  /* set audio service type based on bitstream mode for AC-3 */
1531  avctx->audio_service_type = s->bitstream_mode;
1532  if (s->bitstream_mode == 0x7 && s->channels > 1)
1534 
1535  /* get output buffer */
1536  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1537  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1538  return ret;
1539 
1540  /* decode the audio blocks */
1541  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1542  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1543  output[ch] = s->output[ch];
1544  s->outptr[ch] = s->output[ch];
1545  }
1546  for (ch = 0; ch < s->channels; ch++) {
1547  if (ch < s->out_channels)
1548  s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1549  }
1550  for (blk = 0; blk < s->num_blocks; blk++) {
1551  if (!err && decode_audio_block(s, blk)) {
1552  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1553  err = 1;
1554  }
1555  if (err)
1556  for (ch = 0; ch < s->out_channels; ch++)
1557  memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1558  for (ch = 0; ch < s->out_channels; ch++)
1559  output[ch] = s->outptr[channel_map[ch]];
1560  for (ch = 0; ch < s->out_channels; ch++) {
1561  if (!ch || channel_map[ch])
1562  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1563  }
1564  }
1565 
1567 
1568  /* keep last block for error concealment in next frame */
1569  for (ch = 0; ch < s->out_channels; ch++)
1570  memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1571 
1572  /*
1573  * AVMatrixEncoding
1574  *
1575  * Check whether the input layout is compatible, and make sure we're not
1576  * downmixing (else the matrix encoding is no longer applicable).
1577  */
1578  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1579  if (s->channel_mode == AC3_CHMODE_STEREO &&
1580  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1582  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1584  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1585  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1586  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1587  switch (s->dolby_surround_ex_mode) {
1588  case AC3_DSUREXMOD_ON: // EX or PLIIx
1589  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1590  break;
1591  case AC3_DSUREXMOD_PLIIZ:
1592  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1593  break;
1594  default: // not indicated or off
1595  break;
1596  }
1597  }
1598  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1599  return ret;
1600 
1601  /* AVDownmixInfo */
1602  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1603  switch (s->preferred_downmix) {
1604  case AC3_DMIXMOD_LTRT:
1606  break;
1607  case AC3_DMIXMOD_LORO:
1609  break;
1610  case AC3_DMIXMOD_DPLII:
1612  break;
1613  default:
1615  break;
1616  }
1617  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1618  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1619  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1621  if (s->lfe_mix_level_exists)
1622  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1623  else
1624  downmix_info->lfe_mix_level = 0.0; // -inf dB
1625  } else
1626  return AVERROR(ENOMEM);
1627 
1628  *got_frame_ptr = 1;
1629 
1630  return FFMIN(buf_size, s->frame_size);
1631 }
1632 
1633 /**
1634  * Uninitialize the AC-3 decoder.
1635  */
1637 {
1638  AC3DecodeContext *s = avctx->priv_data;
1639  ff_mdct_end(&s->imdct_512);
1640  ff_mdct_end(&s->imdct_256);
1641  av_freep(&s->fdsp);
1642 
1643  return 0;
1644 }
1645 
1646 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1647 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
audio downmix medatata
uint8_t bitstream_mode
Definition: ac3.h:184
float, planar
Definition: samplefmt.h:70
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:96
int dba_nsegs[AC3_MAX_CHANNELS]
number of delta segments
Definition: ac3dec.h:201
float v
const char * s
Definition: avisynth_c.h:631
uint8_t input_buffer[AC3_FRAME_BUFFER_SIZE+AV_INPUT_BUFFER_PADDING_SIZE]
temp buffer to prevent overread
Definition: ac3dec.h:240
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
int16_t psd[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
scaled exponents
Definition: ac3dec.h:197
int spx_in_use
spectral extension in use (spxinu)
Definition: ac3dec.h:138
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t dba_offsets[AC3_MAX_CHANNELS][8]
delta segment offsets
Definition: ac3dec.h:202
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:208
int16_t mask[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
masking curve values
Definition: ac3dec.h:199
int preferred_downmix
Preferred 2-channel downmix mode (dmixmod)
Definition: ac3dec.h:91
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:261
#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
static void ac3_downmix_c_fixed16(int16_t **samples, int16_t(*matrix)[2], 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:143
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
attribute_deprecated int request_channels
Decoder should decode to this many channels if it can (0 for default)
Definition: avcodec.h:2325
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
#define CONFIG_EAC3_DECODER
Definition: config.h:873
#define avpriv_request_sample(...)
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
av_cold void ff_ac3_common_init(void)
Initialize some tables.
Definition: ac3.c:223
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:104
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
#define SHORTFLOAT
Definition: aac_defines.h:87
int size
Definition: avcodec.h:1434
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:501
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, uint8_t absexp, int8_t *dexps)
Decode the grouped exponents according to exponent strategy.
Definition: ac3dec.c:423
int channels
number of total channels
Definition: ac3dec.h:160
int b4
Definition: ac3dec.c:494
AVFloatDSPContext * fdsp
Definition: ac3dec.h:223
int spx_dst_end_freq
spx end frequency bin
Definition: ac3dec.h:142
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, mant_groups *m)
Definition: ac3dec.c:595
#define EXP_REUSE
Definition: ac3.h:47
int exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS]
exponent strategies (expstr)
Definition: ac3dec.h:188
int lfe_on
lfe channel in use
Definition: ac3dec.h:86
#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:213
#define blk(i)
Definition: sha.c:185
int dba_syntax
delta bit allocation syntax enabled (dbaflde)
Definition: ac3dec.h:118
int dialog_normalization[2]
dialog level in dBFS (dialnorm)
Definition: ac3dec.h:87
int spx_src_start_freq
spx start frequency bin
Definition: ac3dec.h:141
int heavy_compression
apply heavy compression
Definition: ac3dec.h:171
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:246
Not indicated.
Definition: downmix_info.h:45
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3dec.h:130
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
#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:2347
int lfe_mix_level_exists
indicates if lfemixlevcod is specified (lfemixlevcode)
Definition: ac3dec.h:96
#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:146
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:103
uint8_t bits
Definition: crc.c:295
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2280
float ltrt_center_mix_level
Definition: ac3dec.h:105
uint8_t
#define av_cold
Definition: attributes.h:74
int first_cpl_coords[AC3_MAX_CHANNELS]
first coupling coordinates states (firstcplcos)
Definition: ac3dec.h:132
AVOptions.
uint8_t lfe_on
Definition: ac3.h:186
#define INTFLOAT
Definition: aac_defines.h:85
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:149
static void do_imdct(AC3DecodeContext *s, int channels)
Inverse MDCT Transform.
Definition: ac3dec.c:675
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
Definition: ac3dec.c:1636
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.
float output[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
output after imdct transform and windowing
Definition: ac3dec.h:239
int num_rematrixing_bands
number of rematrixing bands (nrematbnd)
Definition: ac3dec.h:181
#define AV_CH_LOW_FREQUENCY
int fast_gain[AC3_MAX_CHANNELS]
fast gain values/SMR's (fgain)
Definition: ac3dec.h:195
static AVFrame * frame
float ltrt_surround_mix_level
Definition: ac3dec.h:106
uint8_t * data
Definition: avcodec.h:1433
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:133
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:186
uint8_t sr_shift
Definition: ac3.h:201
#define FIXR12(x)
Definition: ac3.h:82
Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible.
Definition: downmix_info.h:48
uint8_t bitstream_id
Definition: ac3.h:183
AVFixedDSPContext * avpriv_alloc_fixed_dsp(int bit_exact)
Allocate and initialize a fixed DSP context.
Definition: fixed_dsp.c:148
#define LEVEL_MINUS_1POINT5DB
Definition: ac3.h:105
static av_always_inline int fixed_sqrt(int x, int bits)
Calculate the square root.
Definition: fixed_dsp.h:174
static int ff_eac3_parse_header(AC3DecodeContext *s)
Parse the E-AC-3 frame header.
float delay[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
delay - added to the next block
Definition: ac3dec.h:236
int bit_allocation_syntax
bit allocation model syntax enabled (bamode)
Definition: ac3dec.h:116
int phase_flags_in_use
phase flags in use (phsflginu)
Definition: ac3dec.h:126
#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.
unsigned m
Definition: audioconvert.c:187
Grouped mantissas for 3-level 5-level and 11-level quantization.
Definition: ac3dec.c:488
int phase_flags[AC3_MAX_CPL_BANDS]
phase flags (phsflg)
Definition: ac3dec.h:127
int out_channels
number of output channels
Definition: ac3dec.h:165
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
#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:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int decode_audio_block(AC3DecodeContext *s, int blk)
Decode a single audio block from the AC-3 bitstream.
Definition: ac3dec.c:807
#define AC3_DYNAMIC_RANGE1
Definition: ac3.h:93
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:80
uint8_t frame_type
Definition: ac3.h:187
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2911
#define AV_RB16
Definition: intreadwrite.h:53
int lfe_ch
index of LFE channel
Definition: ac3dec.h:161
#define AVERROR(e)
Definition: error.h:43
uint8_t first_spx_coords[AC3_MAX_CHANNELS]
first spx coordinates states (firstspxcos)
Definition: ac3dec.h:148
AC3BitAllocParameters bit_alloc_params
bit allocation parameters
Definition: ac3dec.h:192
int dolby_surround_mode
dolby surround mode (dsurmod)
Definition: ac3dec.h:99
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
Decode the transform coefficients.
Definition: ac3dec.c:615
GetBitContext gbc
bitstream reader
Definition: ac3dec.h:73
static float heavy_dynamic_range_tab[256]
Definition: ac3dec.c:68
uint8_t sr_code
Definition: ac3.h:182
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57
AC3DSPContext ac3dsp
Definition: ac3dec.h:225
#define LEVEL_MINUS_9DB
Definition: ac3.h:109
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:31
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1607
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:123
Definition: ac3.h:116
int dolby_headphone_mode
dolby headphone mode (dheadphonmod)
Definition: ac3dec.h:101
float loro_center_mix_level
Definition: ac3dec.h:107
Coded AC-3 header values up to the lfeon element, plus derived values.
Definition: ac3.h:176
int compression_exists[2]
compression field is valid for frame (compre)
Definition: ac3dec.h:88
#define ff_mdct_init
Definition: fft.h:167
uint16_t sample_rate
Definition: ac3.h:202
#define FFMAX(a, b)
Definition: common.h:90
#define LEVEL_MINUS_3DB
Definition: ac3.h:106
float FFTSample
Definition: avfft.h:35
static int ac3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single AC-3 frame.
Definition: ac3dec.c:1410
int block_switch_syntax
block switch syntax enabled (blkswe)
Definition: ac3dec.h:114
float level_gain[2]
Definition: ac3dec.h:110
int fast_gain_syntax
fast gain codes enabled (frmfgaincode)
Definition: ac3dec.h:117
int16_t band_psd[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
interpolated exponents
Definition: ac3dec.h:198
uint8_t channel_uses_spx[AC3_MAX_CHANNELS]
channel uses spectral extension (chinspx)
Definition: ac3dec.h:139
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2333
#define LEVEL_MINUS_4POINT5DB
Definition: ac3.h:107
static int b3_mantissas[8]
Definition: ac3dec.c:53
#define AC3_BLOCK_SIZE
Definition: ac3.h:35
INTFLOAT dynamic_range[2]
dynamic range
Definition: ac3dec.h:169
#define powf(x, y)
Definition: libm.h:48
static float dynamic_range_tab[256]
dynamic range table.
Definition: ac3dec.c:67
static void do_rematrixing(AC3DecodeContext *s)
Stereo rematrixing.
Definition: ac3dec.c:651
#define AC3_HEAVY_RANGE(x)
Definition: ac3.h:90
SHORTFLOAT * outptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:229
int bit_rate
the average bitrate
Definition: avcodec.h:1577
audio channel layout utility functions
int b4_mant
Definition: ac3dec.c:491
int surround_mix_level_ltrt
Surround mix level index for Lt/Rt (ltrtsurmixlev)
Definition: ac3dec.h:95
BswapDSPContext bdsp
Definition: ac3dec.h:219
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:788
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:2900
float loro_surround_mix_level
Definition: ac3dec.h:108
#define FFMIN(a, b)
Definition: common.h:92
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:115
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3dec.h:177
INTFLOAT heavy_dynamic_range[2]
heavy dynamic range compression
Definition: ac3dec.h:172
uint32_t bit_rate
Definition: ac3.h:203
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:280
uint8_t dba_values[AC3_MAX_CHANNELS][8]
delta values for each segment
Definition: ac3dec.h:204
FFTContext imdct_512
for 512 sample IMDCT
Definition: ac3dec.h:214
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:356
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
Definition: ac3.h:117
int dolby_surround_mode
Definition: ac3.h:209
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:89
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:755
int avpriv_ac3_parse_header2(GetBitContext *gbc, AC3HeaderInfo **phdr)
Parse AC-3 frame header.
Definition: ac3_parser.c:50
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:246
int channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3dec.h:125
#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:159
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:230
uint8_t bap[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
bit allocation pointers
Definition: ac3dec.h:196
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:32
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:129
int sample_rate
samples per second
Definition: avcodec.h:2272
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:446
main external API structure.
Definition: avcodec.h:1512
#define LEVEL_ZERO
Definition: ac3.h:110
#define LEVEL_ONE
Definition: ac3.h:111
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1048
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3dec.h:128
int num_spx_bands
number of spx bands (nspxbnds)
Definition: ac3dec.h:145
void * buf
Definition: avisynth_c.h:553
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:71
static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
Apply spectral extension to each channel by copying lower frequency coefficients to higher frequency ...
float tmp_output[AC3_BLOCK_SIZE]
temporary storage for output before windowing
Definition: ac3dec.h:238
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:305
int b1
Definition: ac3dec.c:492
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:150
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:298
int bitstream_mode
bitstream mode (bsmod)
Definition: ac3dec.h:84
int center_mix_level_ltrt
Center mix level index for Lt/Rt (ltrtcmixlev)
Definition: ac3dec.h:93
static void set_downmix_coeffs(AC3DecodeContext *s)
Set stereo downmixing coefficients based on frame header info.
Definition: ac3dec.c:371
int frame_type
frame type (strmtyp)
Definition: ac3dec.h:77
uint16_t frame_size
Definition: ac3.h:205
static const uint8_t quantization_tab[16]
Quantization table: levels for symmetric.
Definition: ac3dec.c:61
void av_frame_set_decode_error_flags(AVFrame *frame, int val)
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:143
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:555
int eac3
indicates if current frame is E-AC-3
Definition: ac3dec.h:98
int channel_uses_aht[AC3_MAX_CHANNELS]
channel AHT in use (chahtinu)
Definition: ac3dec.h:154
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:296
uint8_t dba_lengths[AC3_MAX_CHANNELS][8]
delta segment lengths
Definition: ac3dec.h:203
static int ac3_parse_header(AC3DecodeContext *s)
Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
Definition: ac3dec.c:240
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
int cpl_in_use[AC3_MAX_BLOCKS]
coupling in use (cplinu)
Definition: ac3dec.h:123
#define AC3_DYNAMIC_RANGE(x)
Definition: ac3.h:91
int dba_mode[AC3_MAX_CHANNELS]
delta bit allocation mode
Definition: ac3dec.h:200
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:342
int first_cpl_leak
first coupling leak state (firstcplleak)
Definition: ac3dec.h:193
int surround_mix_level
Surround mix level index.
Definition: ac3dec.h:94
int snr_offset[AC3_MAX_CHANNELS]
signal-to-noise ratio offsets (snroffst)
Definition: ac3dec.h:194
int downmixed
indicates if coeffs are currently downmixed
Definition: ac3dec.h:163
float window[AC3_BLOCK_SIZE]
window coefficients
Definition: ac3dec.h:237
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
common internal api header.
INTFLOAT * dlyptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:231
#define ff_mdct_end
Definition: fft.h:168
SHORTFLOAT downmix_coeffs[AC3_MAX_CHANNELS][2]
stereo downmix coefficients
Definition: ac3dec.h:162
int surround_mix_level
Surround mix level index.
Definition: ac3.h:190
int num_blocks
number of audio blocks
Definition: ac3dec.h:82
#define AC3_OUTPUT_LFEON
Definition: ac3dec.h:63
FmtConvertContext fmt_conv
optimized conversion functions
Definition: ac3dec.h:226
int b1_mant[2]
Definition: ac3dec.c:489
float transform_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
transform coefficients
Definition: ac3dec.h:235
int center_mix_level
Center mix level index.
Definition: ac3.h:189
static av_cold void ac3_tables_init(void)
Definition: ac3dec.c:121
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2908
int target_level
target level in dBFS
Definition: ac3dec.h:109
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:155
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1554
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:97
int rematrixing_flags[4]
rematrixing flags (rematflg)
Definition: ac3dec.h:182
int fixed_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
fixed-point transform coefficients
Definition: ac3dec.h:234
uint8_t spx_band_sizes[SPX_MAX_BANDS]
number of bins in each spx band
Definition: ac3dec.h:147
int lfe_mix_level
LFE mix level index (lfemixlevcod)
Definition: ac3dec.h:97
#define AC3_SPX_BLEND(x)
Definition: ac3.h:92
static int parse_frame_header(AC3DecodeContext *s)
Common function to parse AC-3 or E-AC-3 frame header.
Definition: ac3dec.c:304
#define LEVEL_PLUS_3DB
Definition: ac3.h:103
int snr_offset_strategy
SNR offset strategy (snroffststr)
Definition: ac3dec.h:113
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
int b2_mant[2]
Definition: ac3dec.c:490
static const int16_t coeffs[]
av_cold void ff_fmt_convert_init(FmtConvertContext *c, AVCodecContext *avctx)
Definition: fmtconvert.c:44
int start_freq[AC3_MAX_CHANNELS]
start frequency bin (strtmant)
Definition: ac3dec.h:176
int substreamid
substream identification
Definition: ac3.h:188
int channels
number of audio channels
Definition: avcodec.h:2273
int sample_rate
sample frequency, in Hz
Definition: ac3dec.h:81
int center_mix_level
Center mix level index.
Definition: ac3dec.h:92
uint8_t channels
Definition: ac3.h:204
int output_mode
output channel configuration
Definition: ac3dec.h:164
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:460
static const float gain_levels_lfe[32]
Adjustments in dB gain (LFE, +10 to -21 dB)
Definition: ac3dec.c:84
#define LEVEL_MINUS_6DB
Definition: ac3.h:108
void(* downmix)(float **samples, float(*matrix)[2], int out_ch, int in_ch, int len)
Definition: ac3dsp.h:135
int frame_size
current frame size, in bytes
Definition: ac3dec.h:79
static int symmetric_dequant(int code, int levels)
Symmetrical Dequantization reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantizati...
Definition: ac3dec.c:113
#define av_freep(p)
static void ac3_upmix_delay(AC3DecodeContext *s)
Upmix delay samples from stereo to original channel layout.
Definition: ac3dec.c:713
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:68
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:100
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:192
uint8_t channel_mode
Definition: ac3.h:185
AVLFG dith_state
for dither generation
Definition: ac3dec.h:209
int cpl_strategy_exists[AC3_MAX_BLOCKS]
coupling strategy exists (cplstre)
Definition: ac3dec.h:124
static av_cold int ac3_decode_init(AVCodecContext *avctx)
AVCodec initialization.
Definition: ac3dec.c:181
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:292
int bitstream_id
bitstream id (bsid)
Definition: ac3dec.h:83
#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:2340
static void remove_dithering(AC3DecodeContext *s)
Remove random dithering from coupling range coefficients with zero-bit mantissas for coupled channels...
Definition: ac3dec.c:582
This structure stores compressed data.
Definition: avcodec.h:1410
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:225
#define EXP_D45
Definition: ac3.h:52
int channel_mode
channel mode (acmod)
Definition: ac3dec.h:85
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:143
#define AC3_RENAME(x)
Definition: ac3.h:86
int skip_syntax
skip field syntax enabled (skipflde)
Definition: ac3dec.h:119
enum AVDownmixType preferred_downmix_type
Type of downmix preferred by the mastering engineer.
Definition: downmix_info.h:62
int b2
Definition: ac3dec.c:493
int8_t dexps[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
decoded exponents
Definition: ac3dec.h:187
#define MULH
Definition: mathops.h:42
#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:2914