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  */
765 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
766  int ecpl, int start_subband, int end_subband,
767  const uint8_t *default_band_struct,
768  int *num_bands, uint8_t *band_sizes)
769 {
770  int subbnd, bnd, n_subbands, n_bands=0;
771  uint8_t bnd_sz[22];
772  uint8_t coded_band_struct[22];
773  const uint8_t *band_struct;
774 
775  n_subbands = end_subband - start_subband;
776 
777  /* decode band structure from bitstream or use default */
778  if (!eac3 || get_bits1(gbc)) {
779  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
780  coded_band_struct[subbnd] = get_bits1(gbc);
781  }
782  band_struct = coded_band_struct;
783  } else if (!blk) {
784  band_struct = &default_band_struct[start_subband+1];
785  } else {
786  /* no change in band structure */
787  return;
788  }
789 
790  /* calculate number of bands and band sizes based on band structure.
791  note that the first 4 subbands in enhanced coupling span only 6 bins
792  instead of 12. */
793  if (num_bands || band_sizes ) {
794  n_bands = n_subbands;
795  bnd_sz[0] = ecpl ? 6 : 12;
796  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
797  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
798  if (band_struct[subbnd - 1]) {
799  n_bands--;
800  bnd_sz[bnd] += subbnd_size;
801  } else {
802  bnd_sz[++bnd] = subbnd_size;
803  }
804  }
805  }
806 
807  /* set optional output params */
808  if (num_bands)
809  *num_bands = n_bands;
810  if (band_sizes)
811  memcpy(band_sizes, bnd_sz, n_bands);
812 }
813 
814 static inline int spx_strategy(AC3DecodeContext *s, int blk)
815 {
816  GetBitContext *bc = &s->gbc;
817  int fbw_channels = s->fbw_channels;
818  int dst_start_freq, dst_end_freq, src_start_freq,
819  start_subband, end_subband, ch;
820 
821  /* determine which channels use spx */
822  if (s->channel_mode == AC3_CHMODE_MONO) {
823  s->channel_uses_spx[1] = 1;
824  } else {
825  for (ch = 1; ch <= fbw_channels; ch++)
826  s->channel_uses_spx[ch] = get_bits1(bc);
827  }
828 
829  /* get the frequency bins of the spx copy region and the spx start
830  and end subbands */
831  dst_start_freq = get_bits(bc, 2);
832  start_subband = get_bits(bc, 3) + 2;
833  if (start_subband > 7)
834  start_subband += start_subband - 7;
835  end_subband = get_bits(bc, 3) + 5;
836 #if USE_FIXED
837  s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
838 #endif
839  if (end_subband > 7)
840  end_subband += end_subband - 7;
841  dst_start_freq = dst_start_freq * 12 + 25;
842  src_start_freq = start_subband * 12 + 25;
843  dst_end_freq = end_subband * 12 + 25;
844 
845  /* check validity of spx ranges */
846  if (start_subband >= end_subband) {
847  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
848  "range (%d >= %d)\n", start_subband, end_subband);
849  return AVERROR_INVALIDDATA;
850  }
851  if (dst_start_freq >= src_start_freq) {
852  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
853  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
854  return AVERROR_INVALIDDATA;
855  }
856 
857  s->spx_dst_start_freq = dst_start_freq;
858  s->spx_src_start_freq = src_start_freq;
859  if (!USE_FIXED)
860  s->spx_dst_end_freq = dst_end_freq;
861 
862  decode_band_structure(bc, blk, s->eac3, 0,
863  start_subband, end_subband,
865  &s->num_spx_bands,
866  s->spx_band_sizes);
867  return 0;
868 }
869 
870 static inline void spx_coordinates(AC3DecodeContext *s)
871 {
872  GetBitContext *bc = &s->gbc;
873  int fbw_channels = s->fbw_channels;
874  int ch, bnd;
875 
876  for (ch = 1; ch <= fbw_channels; ch++) {
877  if (s->channel_uses_spx[ch]) {
878  if (s->first_spx_coords[ch] || get_bits1(bc)) {
879  INTFLOAT spx_blend;
880  int bin, master_spx_coord;
881 
882  s->first_spx_coords[ch] = 0;
883  spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
884  master_spx_coord = get_bits(bc, 2) * 3;
885 
886  bin = s->spx_src_start_freq;
887  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
888  int bandsize = s->spx_band_sizes[bnd];
889  int spx_coord_exp, spx_coord_mant;
890  INTFLOAT nratio, sblend, nblend;
891 #if USE_FIXED
892  /* calculate blending factors */
893  int64_t accu = ((bin << 23) + (bandsize << 22))
894  * (int64_t)s->spx_dst_end_freq;
895  nratio = (int)(accu >> 32);
896  nratio -= spx_blend << 18;
897 
898  if (nratio < 0) {
899  nblend = 0;
900  sblend = 0x800000;
901  } else if (nratio > 0x7fffff) {
902  nblend = 14529495; // sqrt(3) in FP.23
903  sblend = 0;
904  } else {
905  nblend = fixed_sqrt(nratio, 23);
906  accu = (int64_t)nblend * 1859775393;
907  nblend = (int)((accu + (1<<29)) >> 30);
908  sblend = fixed_sqrt(0x800000 - nratio, 23);
909  }
910 #else
911  float spx_coord;
912 
913  /* calculate blending factors */
914  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
915  nratio = av_clipf(nratio, 0.0f, 1.0f);
916  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
917  // to give unity variance
918  sblend = sqrtf(1.0f - nratio);
919 #endif
920  bin += bandsize;
921 
922  /* decode spx coordinates */
923  spx_coord_exp = get_bits(bc, 4);
924  spx_coord_mant = get_bits(bc, 2);
925  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
926  else spx_coord_mant += 4;
927  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
928 
929  /* multiply noise and signal blending factors by spx coordinate */
930 #if USE_FIXED
931  accu = (int64_t)nblend * spx_coord_mant;
932  s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
933  accu = (int64_t)sblend * spx_coord_mant;
934  s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
935 #else
936  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
937  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
938  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
939 #endif
940  }
941  }
942  } else {
943  s->first_spx_coords[ch] = 1;
944  }
945  }
946 }
947 
948 static inline int coupling_strategy(AC3DecodeContext *s, int blk,
949  uint8_t *bit_alloc_stages)
950 {
951  GetBitContext *bc = &s->gbc;
952  int fbw_channels = s->fbw_channels;
953  int channel_mode = s->channel_mode;
954  int ch;
955 
956  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
957  if (!s->eac3)
958  s->cpl_in_use[blk] = get_bits1(bc);
959  if (s->cpl_in_use[blk]) {
960  /* coupling in use */
961  int cpl_start_subband, cpl_end_subband;
962 
963  if (channel_mode < AC3_CHMODE_STEREO) {
964  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
965  return AVERROR_INVALIDDATA;
966  }
967 
968  /* check for enhanced coupling */
969  if (s->eac3 && get_bits1(bc)) {
970  /* TODO: parse enhanced coupling strategy info */
971  avpriv_request_sample(s->avctx, "Enhanced coupling");
972  return AVERROR_PATCHWELCOME;
973  }
974 
975  /* determine which channels are coupled */
976  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
977  s->channel_in_cpl[1] = 1;
978  s->channel_in_cpl[2] = 1;
979  } else {
980  for (ch = 1; ch <= fbw_channels; ch++)
981  s->channel_in_cpl[ch] = get_bits1(bc);
982  }
983 
984  /* phase flags in use */
985  if (channel_mode == AC3_CHMODE_STEREO)
986  s->phase_flags_in_use = get_bits1(bc);
987 
988  /* coupling frequency range */
989  cpl_start_subband = get_bits(bc, 4);
990  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
991  get_bits(bc, 4) + 3;
992  if (cpl_start_subband >= cpl_end_subband) {
993  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
994  cpl_start_subband, cpl_end_subband);
995  return AVERROR_INVALIDDATA;
996  }
997  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
998  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
999 
1000  decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1001  cpl_end_subband,
1003  &s->num_cpl_bands, s->cpl_band_sizes);
1004  } else {
1005  /* coupling not in use */
1006  for (ch = 1; ch <= fbw_channels; ch++) {
1007  s->channel_in_cpl[ch] = 0;
1008  s->first_cpl_coords[ch] = 1;
1009  }
1010  s->first_cpl_leak = s->eac3;
1011  s->phase_flags_in_use = 0;
1012  }
1013 
1014  return 0;
1015 }
1016 
1017 static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1018 {
1019  GetBitContext *bc = &s->gbc;
1020  int fbw_channels = s->fbw_channels;
1021  int ch, bnd;
1022  int cpl_coords_exist = 0;
1023 
1024  for (ch = 1; ch <= fbw_channels; ch++) {
1025  if (s->channel_in_cpl[ch]) {
1026  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1027  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1028  s->first_cpl_coords[ch] = 0;
1029  cpl_coords_exist = 1;
1030  master_cpl_coord = 3 * get_bits(bc, 2);
1031  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1032  cpl_coord_exp = get_bits(bc, 4);
1033  cpl_coord_mant = get_bits(bc, 4);
1034  if (cpl_coord_exp == 15)
1035  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1036  else
1037  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1038  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1039  }
1040  } else if (!blk) {
1041  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1042  "be present in block 0\n");
1043  return AVERROR_INVALIDDATA;
1044  }
1045  } else {
1046  /* channel not in coupling */
1047  s->first_cpl_coords[ch] = 1;
1048  }
1049  }
1050  /* phase flags */
1051  if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1052  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1053  s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1054  }
1055  }
1056 
1057  return 0;
1058 }
1059 
1060 /**
1061  * Decode a single audio block from the AC-3 bitstream.
1062  */
1064 {
1065  int fbw_channels = s->fbw_channels;
1066  int channel_mode = s->channel_mode;
1067  int i, bnd, seg, ch, ret;
1068  int different_transforms;
1069  int downmix_output;
1070  int cpl_in_use;
1071  GetBitContext *gbc = &s->gbc;
1072  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1073 
1074  /* block switch flags */
1075  different_transforms = 0;
1076  if (s->block_switch_syntax) {
1077  for (ch = 1; ch <= fbw_channels; ch++) {
1078  s->block_switch[ch] = get_bits1(gbc);
1079  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1080  different_transforms = 1;
1081  }
1082  }
1083 
1084  /* dithering flags */
1085  if (s->dither_flag_syntax) {
1086  for (ch = 1; ch <= fbw_channels; ch++) {
1087  s->dither_flag[ch] = get_bits1(gbc);
1088  }
1089  }
1090 
1091  /* dynamic range */
1092  i = !s->channel_mode;
1093  do {
1094  if (get_bits1(gbc)) {
1095  /* Allow asymmetric application of DRC when drc_scale > 1.
1096  Amplification of quiet sounds is enhanced */
1097  int range_bits = get_bits(gbc, 8);
1098  INTFLOAT range = AC3_RANGE(range_bits);
1099  if (range_bits <= 127 || s->drc_scale <= 1.0)
1100  s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1101  else
1102  s->dynamic_range[i] = range;
1103  } else if (blk == 0) {
1105  }
1106  } while (i--);
1107 
1108  /* spectral extension strategy */
1109  if (s->eac3 && (!blk || get_bits1(gbc))) {
1110  s->spx_in_use = get_bits1(gbc);
1111  if (s->spx_in_use) {
1112  if ((ret = spx_strategy(s, blk)) < 0)
1113  return ret;
1114  }
1115  }
1116  if (!s->eac3 || !s->spx_in_use) {
1117  s->spx_in_use = 0;
1118  for (ch = 1; ch <= fbw_channels; ch++) {
1119  s->channel_uses_spx[ch] = 0;
1120  s->first_spx_coords[ch] = 1;
1121  }
1122  }
1123 
1124  /* spectral extension coordinates */
1125  if (s->spx_in_use)
1126  spx_coordinates(s);
1127 
1128  /* coupling strategy */
1129  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1130  if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1131  return ret;
1132  } else if (!s->eac3) {
1133  if (!blk) {
1134  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1135  "be present in block 0\n");
1136  return AVERROR_INVALIDDATA;
1137  } else {
1138  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1139  }
1140  }
1141  cpl_in_use = s->cpl_in_use[blk];
1142 
1143  /* coupling coordinates */
1144  if (cpl_in_use) {
1145  if ((ret = coupling_coordinates(s, blk)) < 0)
1146  return ret;
1147  }
1148 
1149  /* stereo rematrixing strategy and band structure */
1150  if (channel_mode == AC3_CHMODE_STEREO) {
1151  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1152  s->num_rematrixing_bands = 4;
1153  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1154  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1155  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1156  s->num_rematrixing_bands--;
1157  }
1158  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1159  s->rematrixing_flags[bnd] = get_bits1(gbc);
1160  } else if (!blk) {
1161  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1162  "new rematrixing strategy not present in block 0\n");
1163  s->num_rematrixing_bands = 0;
1164  }
1165  }
1166 
1167  /* exponent strategies for each channel */
1168  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1169  if (!s->eac3)
1170  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1171  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1172  bit_alloc_stages[ch] = 3;
1173  }
1174 
1175  /* channel bandwidth */
1176  for (ch = 1; ch <= fbw_channels; ch++) {
1177  s->start_freq[ch] = 0;
1178  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1179  int group_size;
1180  int prev = s->end_freq[ch];
1181  if (s->channel_in_cpl[ch])
1182  s->end_freq[ch] = s->start_freq[CPL_CH];
1183  else if (s->channel_uses_spx[ch])
1184  s->end_freq[ch] = s->spx_src_start_freq;
1185  else {
1186  int bandwidth_code = get_bits(gbc, 6);
1187  if (bandwidth_code > 60) {
1188  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1189  return AVERROR_INVALIDDATA;
1190  }
1191  s->end_freq[ch] = bandwidth_code * 3 + 73;
1192  }
1193  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1194  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1195  if (blk > 0 && s->end_freq[ch] != prev)
1196  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1197  }
1198  }
1199  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1201  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1202  }
1203 
1204  /* decode exponents for each channel */
1205  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1206  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1207  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1208  if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1209  s->num_exp_groups[ch], s->dexps[ch][0],
1210  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1211  return AVERROR_INVALIDDATA;
1212  }
1213  if (ch != CPL_CH && ch != s->lfe_ch)
1214  skip_bits(gbc, 2); /* skip gainrng */
1215  }
1216  }
1217 
1218  /* bit allocation information */
1219  if (s->bit_allocation_syntax) {
1220  if (get_bits1(gbc)) {
1226  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1227  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1228  } else if (!blk) {
1229  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1230  "be present in block 0\n");
1231  return AVERROR_INVALIDDATA;
1232  }
1233  }
1234 
1235  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1236  if (!s->eac3 || !blk) {
1237  if (s->snr_offset_strategy && get_bits1(gbc)) {
1238  int snr = 0;
1239  int csnr;
1240  csnr = (get_bits(gbc, 6) - 15) << 4;
1241  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1242  /* snr offset */
1243  if (ch == i || s->snr_offset_strategy == 2)
1244  snr = (csnr + get_bits(gbc, 4)) << 2;
1245  /* run at least last bit allocation stage if snr offset changes */
1246  if (blk && s->snr_offset[ch] != snr) {
1247  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1248  }
1249  s->snr_offset[ch] = snr;
1250 
1251  /* fast gain (normal AC-3 only) */
1252  if (!s->eac3) {
1253  int prev = s->fast_gain[ch];
1254  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1255  /* run last 2 bit allocation stages if fast gain changes */
1256  if (blk && prev != s->fast_gain[ch])
1257  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1258  }
1259  }
1260  } else if (!s->eac3 && !blk) {
1261  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1262  return AVERROR_INVALIDDATA;
1263  }
1264  }
1265 
1266  /* fast gain (E-AC-3 only) */
1267  if (s->fast_gain_syntax && get_bits1(gbc)) {
1268  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1269  int prev = s->fast_gain[ch];
1270  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1271  /* run last 2 bit allocation stages if fast gain changes */
1272  if (blk && prev != s->fast_gain[ch])
1273  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1274  }
1275  } else if (s->eac3 && !blk) {
1276  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1277  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1278  }
1279 
1280  /* E-AC-3 to AC-3 converter SNR offset */
1281  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1282  skip_bits(gbc, 10); // skip converter snr offset
1283  }
1284 
1285  /* coupling leak information */
1286  if (cpl_in_use) {
1287  if (s->first_cpl_leak || get_bits1(gbc)) {
1288  int fl = get_bits(gbc, 3);
1289  int sl = get_bits(gbc, 3);
1290  /* run last 2 bit allocation stages for coupling channel if
1291  coupling leak changes */
1292  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1293  sl != s->bit_alloc_params.cpl_slow_leak)) {
1294  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1295  }
1298  } else if (!s->eac3 && !blk) {
1299  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1300  "be present in block 0\n");
1301  return AVERROR_INVALIDDATA;
1302  }
1303  s->first_cpl_leak = 0;
1304  }
1305 
1306  /* delta bit allocation information */
1307  if (s->dba_syntax && get_bits1(gbc)) {
1308  /* delta bit allocation exists (strategy) */
1309  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1310  s->dba_mode[ch] = get_bits(gbc, 2);
1311  if (s->dba_mode[ch] == DBA_RESERVED) {
1312  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1313  return AVERROR_INVALIDDATA;
1314  }
1315  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1316  }
1317  /* channel delta offset, len and bit allocation */
1318  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1319  if (s->dba_mode[ch] == DBA_NEW) {
1320  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1321  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1322  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1323  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1324  s->dba_values[ch][seg] = get_bits(gbc, 3);
1325  }
1326  /* run last 2 bit allocation stages if new dba values */
1327  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1328  }
1329  }
1330  } else if (blk == 0) {
1331  for (ch = 0; ch <= s->channels; ch++) {
1332  s->dba_mode[ch] = DBA_NONE;
1333  }
1334  }
1335 
1336  /* Bit allocation */
1337  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1338  if (bit_alloc_stages[ch] > 2) {
1339  /* Exponent mapping into PSD and PSD integration */
1341  s->start_freq[ch], s->end_freq[ch],
1342  s->psd[ch], s->band_psd[ch]);
1343  }
1344  if (bit_alloc_stages[ch] > 1) {
1345  /* Compute excitation function, Compute masking curve, and
1346  Apply delta bit allocation */
1348  s->start_freq[ch], s->end_freq[ch],
1349  s->fast_gain[ch], (ch == s->lfe_ch),
1350  s->dba_mode[ch], s->dba_nsegs[ch],
1351  s->dba_offsets[ch], s->dba_lengths[ch],
1352  s->dba_values[ch], s->mask[ch])) {
1353  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1354  return AVERROR_INVALIDDATA;
1355  }
1356  }
1357  if (bit_alloc_stages[ch] > 0) {
1358  /* Compute bit allocation */
1359  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1361  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1362  s->start_freq[ch], s->end_freq[ch],
1363  s->snr_offset[ch],
1365  bap_tab, s->bap[ch]);
1366  }
1367  }
1368 
1369  /* unused dummy data */
1370  if (s->skip_syntax && get_bits1(gbc)) {
1371  int skipl = get_bits(gbc, 9);
1372  skip_bits_long(gbc, 8 * skipl);
1373  }
1374 
1375  /* unpack the transform coefficients
1376  this also uncouples channels if coupling is in use. */
1377  decode_transform_coeffs(s, blk);
1378 
1379  /* TODO: generate enhanced coupling coordinates and uncouple */
1380 
1381  /* recover coefficients if rematrixing is in use */
1382  if (s->channel_mode == AC3_CHMODE_STEREO)
1383  do_rematrixing(s);
1384 
1385  /* apply scaling to coefficients (headroom, dynrng) */
1386  for (ch = 1; ch <= s->channels; ch++) {
1387  int audio_channel = 0;
1388  INTFLOAT gain;
1390  audio_channel = 2-ch;
1391  if (s->heavy_compression && s->compression_exists[audio_channel])
1392  gain = s->heavy_dynamic_range[audio_channel];
1393  else
1394  gain = s->dynamic_range[audio_channel];
1395 
1396 #if USE_FIXED
1397  scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1398 #else
1399  if (s->target_level != 0)
1400  gain = gain * s->level_gain[audio_channel];
1401  gain *= 1.0 / 4194304.0f;
1403  s->fixed_coeffs[ch], gain, 256);
1404 #endif
1405  }
1406 
1407  /* apply spectral extension to high frequency bins */
1408  if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1410  }
1411 
1412  /* downmix and MDCT. order depends on whether block switching is used for
1413  any channel in this block. this is because coefficients for the long
1414  and short transforms cannot be mixed. */
1415  downmix_output = s->channels != s->out_channels &&
1416  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1417  s->fbw_channels == s->out_channels);
1418  if (different_transforms) {
1419  /* the delay samples have already been downmixed, so we upmix the delay
1420  samples in order to reconstruct all channels before downmixing. */
1421  if (s->downmixed) {
1422  s->downmixed = 0;
1423  ac3_upmix_delay(s);
1424  }
1425 
1426  do_imdct(s, s->channels);
1427 
1428  if (downmix_output) {
1429 #if USE_FIXED
1431  s->out_channels, s->fbw_channels, 256);
1432 #else
1434  s->out_channels, s->fbw_channels, 256);
1435 #endif
1436  }
1437  } else {
1438  if (downmix_output) {
1440  s->out_channels, s->fbw_channels, 256);
1441  }
1442 
1443  if (downmix_output && !s->downmixed) {
1444  s->downmixed = 1;
1446  s->out_channels, s->fbw_channels, 128);
1447  }
1448 
1449  do_imdct(s, s->out_channels);
1450  }
1451 
1452  return 0;
1453 }
1454 
1455 /**
1456  * Decode a single AC-3 frame.
1457  */
1458 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1459  int *got_frame_ptr, AVPacket *avpkt)
1460 {
1461  AVFrame *frame = data;
1462  const uint8_t *buf = avpkt->data;
1463  int buf_size = avpkt->size;
1464  AC3DecodeContext *s = avctx->priv_data;
1465  int blk, ch, err, ret;
1466  const uint8_t *channel_map;
1467  const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1468  enum AVMatrixEncoding matrix_encoding;
1469  AVDownmixInfo *downmix_info;
1470 
1471  /* copy input buffer to decoder context to avoid reading past the end
1472  of the buffer, which can be caused by a damaged input stream. */
1473  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1474  // seems to be byte-swapped AC-3
1475  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1476  s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1477  (const uint16_t *) buf, cnt);
1478  } else
1479  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1480 
1481  /* if consistent noise generation is enabled, seed the linear feedback generator
1482  * with the contents of the AC-3 frame so that the noise is identical across
1483  * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1486 
1487  buf = s->input_buffer;
1488  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1489  if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1490  return ret;
1491 
1492  /* parse the syncinfo */
1493  err = parse_frame_header(s);
1494 
1495  if (err) {
1496  switch (err) {
1498  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1499  return AVERROR_INVALIDDATA;
1501  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1502  break;
1504  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1505  break;
1507  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1508  break;
1510  /* skip frame if CRC is ok. otherwise use error concealment. */
1511  /* TODO: add support for substreams and dependent frames */
1513  av_log(avctx, AV_LOG_DEBUG,
1514  "unsupported frame type %d: skipping frame\n",
1515  s->frame_type);
1516  *got_frame_ptr = 0;
1517  return buf_size;
1518  } else {
1519  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1520  }
1521  break;
1524  break;
1525  default: // Normal AVERROR do not try to recover.
1526  *got_frame_ptr = 0;
1527  return err;
1528  }
1529  } else {
1530  /* check that reported frame size fits in input buffer */
1531  if (s->frame_size > buf_size) {
1532  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1534  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1535  /* check for crc mismatch */
1536  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1537  s->frame_size - 2)) {
1538  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1539  if (avctx->err_recognition & AV_EF_EXPLODE)
1540  return AVERROR_INVALIDDATA;
1542  }
1543  }
1544  }
1545 
1546  /* if frame is ok, set audio parameters */
1547  if (!err) {
1548  avctx->sample_rate = s->sample_rate;
1549  avctx->bit_rate = s->bit_rate;
1550  }
1551 
1552  /* channel config */
1553  if (!err || (s->channels && s->out_channels != s->channels)) {
1554  s->out_channels = s->channels;
1555  s->output_mode = s->channel_mode;
1556  if (s->lfe_on)
1558  if (s->channels > 1 &&
1560  s->out_channels = 1;
1562  } else if (s->channels > 2 &&
1564  s->out_channels = 2;
1566  }
1567 
1568  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1572  /* set downmixing coefficients if needed */
1573  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1574  s->fbw_channels == s->out_channels)) {
1575  if ((ret = set_downmix_coeffs(s)) < 0) {
1576  av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1577  return ret;
1578  }
1579  }
1580  } else if (!s->channels) {
1581  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1582  return AVERROR_INVALIDDATA;
1583  }
1584  avctx->channels = s->out_channels;
1586  if (s->output_mode & AC3_OUTPUT_LFEON)
1588 
1589  /* set audio service type based on bitstream mode for AC-3 */
1590  avctx->audio_service_type = s->bitstream_mode;
1591  if (s->bitstream_mode == 0x7 && s->channels > 1)
1593 
1594  /* get output buffer */
1595  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1596  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1597  return ret;
1598 
1599  /* decode the audio blocks */
1600  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1601  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1602  output[ch] = s->output[ch];
1603  s->outptr[ch] = s->output[ch];
1604  }
1605  for (ch = 0; ch < s->channels; ch++) {
1606  if (ch < s->out_channels)
1607  s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1608  }
1609  for (blk = 0; blk < s->num_blocks; blk++) {
1610  if (!err && decode_audio_block(s, blk)) {
1611  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1612  err = 1;
1613  }
1614  if (err)
1615  for (ch = 0; ch < s->out_channels; ch++)
1616  memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1617  for (ch = 0; ch < s->out_channels; ch++)
1618  output[ch] = s->outptr[channel_map[ch]];
1619  for (ch = 0; ch < s->out_channels; ch++) {
1620  if (!ch || channel_map[ch])
1621  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1622  }
1623  }
1624 
1626 
1627  /* keep last block for error concealment in next frame */
1628  for (ch = 0; ch < s->out_channels; ch++)
1629  memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1630 
1631  /*
1632  * AVMatrixEncoding
1633  *
1634  * Check whether the input layout is compatible, and make sure we're not
1635  * downmixing (else the matrix encoding is no longer applicable).
1636  */
1637  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1638  if (s->channel_mode == AC3_CHMODE_STEREO &&
1639  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1641  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1643  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1644  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1645  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1646  switch (s->dolby_surround_ex_mode) {
1647  case AC3_DSUREXMOD_ON: // EX or PLIIx
1648  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1649  break;
1650  case AC3_DSUREXMOD_PLIIZ:
1651  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1652  break;
1653  default: // not indicated or off
1654  break;
1655  }
1656  }
1657  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1658  return ret;
1659 
1660  /* AVDownmixInfo */
1661  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1662  switch (s->preferred_downmix) {
1663  case AC3_DMIXMOD_LTRT:
1665  break;
1666  case AC3_DMIXMOD_LORO:
1668  break;
1669  case AC3_DMIXMOD_DPLII:
1671  break;
1672  default:
1674  break;
1675  }
1676  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1677  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1678  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1680  if (s->lfe_mix_level_exists)
1681  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1682  else
1683  downmix_info->lfe_mix_level = 0.0; // -inf dB
1684  } else
1685  return AVERROR(ENOMEM);
1686 
1687  *got_frame_ptr = 1;
1688 
1689  return FFMIN(buf_size, s->frame_size);
1690 }
1691 
1692 /**
1693  * Uninitialize the AC-3 decoder.
1694  */
1696 {
1697  AC3DecodeContext *s = avctx->priv_data;
1698  ff_mdct_end(&s->imdct_512);
1699  ff_mdct_end(&s->imdct_256);
1700  av_freep(&s->fdsp);
1701  av_freep(&s->downmix_coeffs[0]);
1702 
1703  return 0;
1704 }
1705 
1706 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1707 #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:162
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:948
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:205
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:244
#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:193
int16_t psd[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
scaled exponents
Definition: ac3dec.h:201
int spx_in_use
spectral extension in use (spxinu)
Definition: ac3dec.h:139
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:765
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static int spx_strategy(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:814
uint8_t dba_offsets[AC3_MAX_CHANNELS][8]
delta segment offsets
Definition: ac3dec.h:206
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:212
int16_t mask[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
masking curve values
Definition: ac3dec.h:203
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:1797
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
#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:1658
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:160
int b4
Definition: ac3dec.c:505
AVFloatDSPContext * fdsp
Definition: ac3dec.h:227
int spx_dst_end_freq
spx end frequency bin
Definition: ac3dec.h:143
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:192
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:217
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:142
int heavy_compression
apply heavy compression
Definition: ac3dec.h:171
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:246
Not indicated.
Definition: downmix_info.h:45
static void spx_coordinates(AC3DecodeContext *s)
Definition: ac3dec.c:870
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3dec.h:131
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:243
#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:2559
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:119
uint8_t bits
Definition: crc.c:296
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2502
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:133
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:149
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:1695
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:185
#define AV_CH_LOW_FREQUENCY
int fast_gain[AC3_MAX_CHANNELS]
fast gain values/SMR's (fgain)
Definition: ac3dec.h:199
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:1657
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:134
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:190
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:240
int phase_flags[AC3_MAX_CPL_BANDS]
phase flags (phsflg)
Definition: ac3dec.h:129
int out_channels
number of output channels
Definition: ac3dec.h:165
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:89
This structure describes optional metadata relevant to a downmix procedure.
Definition: downmix_info.h:58
int consistent_noise_generation
seed noise generation with AC-3 frame on decode
Definition: ac3dec.h:181
#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:219
#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:1063
#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:161
#define AVERROR(e)
Definition: error.h:43
uint8_t first_spx_coords[AC3_MAX_CHANNELS]
first spx coordinates states (firstspxcos)
Definition: ac3dec.h:148
AC3BitAllocParameters bit_alloc_params
bit allocation parameters
Definition: ac3dec.h:196
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:229
#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:1827
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:239
#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:1458
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:202
uint8_t channel_uses_spx[AC3_MAX_CHANNELS]
channel uses spectral extension (chinspx)
Definition: ac3dec.h:140
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2545
#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:169
#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:241
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:233
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:223
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:924
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:3020
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:177
INTFLOAT heavy_dynamic_range[2]
heavy dynamic range compression
Definition: ac3dec.h:172
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:242
uint8_t dba_values[AC3_MAX_CHANNELS][8]
delta values for each segment
Definition: ac3dec.h:208
FFTContext imdct_512
for 512 sample IMDCT
Definition: ac3dec.h:218
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:3031
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: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:159
void(* bit_alloc_calc_bap)(int16_t *mask, int16_t *psd, int start, int end, int snr_offset, int floor, const uint8_t *bap_tab, uint8_t *bap)
Calculate bit allocation pointers.
Definition: ac3dsp.h:106
INTFLOAT * xcfptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:234
uint8_t bap[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
bit allocation pointers
Definition: ac3dec.h:200
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:2494
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:1732
#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:1601
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:146
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:3034
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:150
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:3028
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:127
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:481
int eac3
indicates if current frame is E-AC-3
Definition: ac3dec.h:98
int channel_uses_aht[AC3_MAX_CHANNELS]
channel AHT in use (chahtinu)
Definition: ac3dec.h:154
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:296
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:480
uint8_t dba_lengths[AC3_MAX_CHANNELS][8]
delta segment lengths
Definition: ac3dec.h:207
static int coupling_coordinates(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:1017
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:207
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:204
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:197
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:198
int downmixed
indicates if coeffs are currently downmixed
Definition: ac3dec.h:163
int
common internal api header.
INTFLOAT * dlyptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:235
#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:230
int b1_mant[2]
Definition: ac3dec.c:500
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_YASM &&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
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:155
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1774
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:186
int fixed_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
fixed-point transform coefficients
Definition: ac3dec.h:238
uint8_t spx_band_sizes[SPX_MAX_BANDS]
number of bins in each spx band
Definition: ac3dec.h:147
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:176
int substreamid
substream identification
Definition: ac3.h:188
int channels
number of audio channels
Definition: avcodec.h:2495
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:164
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
Generate transform coefficients for each coupled channel in the coupling range using the coupling coe...
Definition: ac3dec.c: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:213
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:2552
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:1634
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:250
#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:144
#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:191
#define MULH
Definition: mathops.h:42