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