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