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