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