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