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);
186  ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
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 (avctx->channels > 1 &&
195  avctx->channels = 1;
196  else if (avctx->channels > 2 &&
198  avctx->channels = 2;
199  s->downmixed = 1;
200 
201  for (i = 0; i < AC3_MAX_CHANNELS; i++) {
202  s->xcfptr[i] = s->transform_coeffs[i];
203  s->dlyptr[i] = s->delay[i];
204  }
205 
206  return 0;
207 }
208 
214 static int ac3_parse_header(AC3DecodeContext *s)
215 {
216  GetBitContext *gbc = &s->gbc;
217  int i;
218 
219  /* read the rest of the bsi. read twice for dual mono mode. */
220  i = !s->channel_mode;
221  do {
222  skip_bits(gbc, 5); // skip dialog normalization
223  if (get_bits1(gbc))
224  skip_bits(gbc, 8); //skip compression
225  if (get_bits1(gbc))
226  skip_bits(gbc, 8); //skip language code
227  if (get_bits1(gbc))
228  skip_bits(gbc, 7); //skip audio production information
229  } while (i--);
230 
231  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
232 
233  /* skip the timecodes or parse the Alternate Bit Stream Syntax */
234  if (s->bitstream_id != 6) {
235  if (get_bits1(gbc))
236  skip_bits(gbc, 14); //skip timecode1
237  if (get_bits1(gbc))
238  skip_bits(gbc, 14); //skip timecode2
239  } else {
240  if (get_bits1(gbc)) {
241  s->preferred_downmix = get_bits(gbc, 2);
242  s->center_mix_level_ltrt = get_bits(gbc, 3);
243  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
244  s->center_mix_level = get_bits(gbc, 3);
245  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
246  }
247  if (get_bits1(gbc)) {
248  s->dolby_surround_ex_mode = get_bits(gbc, 2);
249  s->dolby_headphone_mode = get_bits(gbc, 2);
250  skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
251  }
252  }
253 
254  /* skip additional bitstream info */
255  if (get_bits1(gbc)) {
256  i = get_bits(gbc, 6);
257  do {
258  skip_bits(gbc, 8);
259  } while (i--);
260  }
261 
262  return 0;
263 }
264 
268 static int parse_frame_header(AC3DecodeContext *s)
269 {
270  AC3HeaderInfo hdr;
271  int err;
272 
273  err = avpriv_ac3_parse_header(&s->gbc, &hdr);
274  if (err)
275  return err;
276 
277  /* get decoding parameters from header info */
278  s->bit_alloc_params.sr_code = hdr.sr_code;
279  s->bitstream_id = hdr.bitstream_id;
280  s->bitstream_mode = hdr.bitstream_mode;
281  s->channel_mode = hdr.channel_mode;
282  s->lfe_on = hdr.lfe_on;
283  s->bit_alloc_params.sr_shift = hdr.sr_shift;
284  s->sample_rate = hdr.sample_rate;
285  s->bit_rate = hdr.bit_rate;
286  s->channels = hdr.channels;
287  s->fbw_channels = s->channels - s->lfe_on;
288  s->lfe_ch = s->fbw_channels + 1;
289  s->frame_size = hdr.frame_size;
290  s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
291  s->center_mix_level = hdr.center_mix_level;
292  s->center_mix_level_ltrt = 4; // -3.0dB
293  s->surround_mix_level = hdr.surround_mix_level;
294  s->surround_mix_level_ltrt = 4; // -3.0dB
295  s->lfe_mix_level_exists = 0;
296  s->num_blocks = hdr.num_blocks;
297  s->frame_type = hdr.frame_type;
298  s->substreamid = hdr.substreamid;
299  s->dolby_surround_mode = hdr.dolby_surround_mode;
300  s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
301  s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
302 
303  if (s->lfe_on) {
304  s->start_freq[s->lfe_ch] = 0;
305  s->end_freq[s->lfe_ch] = 7;
306  s->num_exp_groups[s->lfe_ch] = 2;
307  s->channel_in_cpl[s->lfe_ch] = 0;
308  }
309 
310  if (s->bitstream_id <= 10) {
311  s->eac3 = 0;
312  s->snr_offset_strategy = 2;
313  s->block_switch_syntax = 1;
314  s->dither_flag_syntax = 1;
315  s->bit_allocation_syntax = 1;
316  s->fast_gain_syntax = 0;
317  s->first_cpl_leak = 0;
318  s->dba_syntax = 1;
319  s->skip_syntax = 1;
320  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
321  return ac3_parse_header(s);
322  } else if (CONFIG_EAC3_DECODER) {
323  s->eac3 = 1;
324  return ff_eac3_parse_header(s);
325  } else {
326  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
327  return AVERROR(ENOSYS);
328  }
329 }
330 
335 static void set_downmix_coeffs(AC3DecodeContext *s)
336 {
337  int i;
338  float cmix = gain_levels[s-> center_mix_level];
339  float smix = gain_levels[s->surround_mix_level];
340  float norm0, norm1;
341 
342  for (i = 0; i < s->fbw_channels; i++) {
343  s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
344  s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
345  }
346  if (s->channel_mode > 1 && s->channel_mode & 1) {
347  s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
348  }
349  if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
350  int nf = s->channel_mode - 2;
351  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
352  }
353  if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
354  int nf = s->channel_mode - 4;
355  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
356  }
357 
358  /* renormalize */
359  norm0 = norm1 = 0.0;
360  for (i = 0; i < s->fbw_channels; i++) {
361  norm0 += s->downmix_coeffs[i][0];
362  norm1 += s->downmix_coeffs[i][1];
363  }
364  norm0 = 1.0f / norm0;
365  norm1 = 1.0f / norm1;
366  for (i = 0; i < s->fbw_channels; i++) {
367  s->downmix_coeffs[i][0] *= norm0;
368  s->downmix_coeffs[i][1] *= norm1;
369  }
370 
371  if (s->output_mode == AC3_CHMODE_MONO) {
372  for (i = 0; i < s->fbw_channels; i++)
373  s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
374  s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
375  }
376 }
377 
382 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
383  uint8_t absexp, int8_t *dexps)
384 {
385  int i, j, grp, group_size;
386  int dexp[256];
387  int expacc, prevexp;
388 
389  /* unpack groups */
390  group_size = exp_strategy + (exp_strategy == EXP_D45);
391  for (grp = 0, i = 0; grp < ngrps; grp++) {
392  expacc = get_bits(gbc, 7);
393  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
394  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
395  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
396  }
397 
398  /* convert to absolute exps and expand groups */
399  prevexp = absexp;
400  for (i = 0, j = 0; i < ngrps * 3; i++) {
401  prevexp += dexp[i] - 2;
402  if (prevexp > 24U)
403  return -1;
404  switch (group_size) {
405  case 4: dexps[j++] = prevexp;
406  dexps[j++] = prevexp;
407  case 2: dexps[j++] = prevexp;
408  case 1: dexps[j++] = prevexp;
409  }
410  }
411  return 0;
412 }
413 
419 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
420 {
421  int bin, band, ch;
422 
423  bin = s->start_freq[CPL_CH];
424  for (band = 0; band < s->num_cpl_bands; band++) {
425  int band_start = bin;
426  int band_end = bin + s->cpl_band_sizes[band];
427  for (ch = 1; ch <= s->fbw_channels; ch++) {
428  if (s->channel_in_cpl[ch]) {
429  int cpl_coord = s->cpl_coords[ch][band] << 5;
430  for (bin = band_start; bin < band_end; bin++) {
431  s->fixed_coeffs[ch][bin] =
432  MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
433  }
434  if (ch == 2 && s->phase_flags[band]) {
435  for (bin = band_start; bin < band_end; bin++)
436  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
437  }
438  }
439  }
440  bin = band_end;
441  }
442 }
443 
447 typedef struct mant_groups {
448  int b1_mant[2];
449  int b2_mant[2];
450  int b4_mant;
451  int b1;
452  int b2;
453  int b4;
454 } mant_groups;
455 
460 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
461 {
462  int start_freq = s->start_freq[ch_index];
463  int end_freq = s->end_freq[ch_index];
464  uint8_t *baps = s->bap[ch_index];
465  int8_t *exps = s->dexps[ch_index];
466  int32_t *coeffs = s->fixed_coeffs[ch_index];
467  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
468  GetBitContext *gbc = &s->gbc;
469  int freq;
470 
471  for (freq = start_freq; freq < end_freq; freq++) {
472  int bap = baps[freq];
473  int mantissa;
474  switch (bap) {
475  case 0:
476  /* random noise with approximate range of -0.707 to 0.707 */
477  if (dither)
478  mantissa = (av_lfg_get(&s->dith_state) / 362) - 5932275;
479  else
480  mantissa = 0;
481  break;
482  case 1:
483  if (m->b1) {
484  m->b1--;
485  mantissa = m->b1_mant[m->b1];
486  } else {
487  int bits = get_bits(gbc, 5);
488  mantissa = b1_mantissas[bits][0];
489  m->b1_mant[1] = b1_mantissas[bits][1];
490  m->b1_mant[0] = b1_mantissas[bits][2];
491  m->b1 = 2;
492  }
493  break;
494  case 2:
495  if (m->b2) {
496  m->b2--;
497  mantissa = m->b2_mant[m->b2];
498  } else {
499  int bits = get_bits(gbc, 7);
500  mantissa = b2_mantissas[bits][0];
501  m->b2_mant[1] = b2_mantissas[bits][1];
502  m->b2_mant[0] = b2_mantissas[bits][2];
503  m->b2 = 2;
504  }
505  break;
506  case 3:
507  mantissa = b3_mantissas[get_bits(gbc, 3)];
508  break;
509  case 4:
510  if (m->b4) {
511  m->b4 = 0;
512  mantissa = m->b4_mant;
513  } else {
514  int bits = get_bits(gbc, 7);
515  mantissa = b4_mantissas[bits][0];
516  m->b4_mant = b4_mantissas[bits][1];
517  m->b4 = 1;
518  }
519  break;
520  case 5:
521  mantissa = b5_mantissas[get_bits(gbc, 4)];
522  break;
523  default: /* 6 to 15 */
524  /* Shift mantissa and sign-extend it. */
525  mantissa = get_sbits(gbc, quantization_tab[bap]);
526  mantissa <<= 24 - quantization_tab[bap];
527  break;
528  }
529  coeffs[freq] = mantissa >> exps[freq];
530  }
531 }
532 
538 static void remove_dithering(AC3DecodeContext *s) {
539  int ch, i;
540 
541  for (ch = 1; ch <= s->fbw_channels; ch++) {
542  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
543  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
544  if (!s->bap[CPL_CH][i])
545  s->fixed_coeffs[ch][i] = 0;
546  }
547  }
548  }
549 }
550 
551 static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
552  int ch, mant_groups *m)
553 {
554  if (!s->channel_uses_aht[ch]) {
556  } else {
557  /* if AHT is used, mantissas for all blocks are encoded in the first
558  block of the frame. */
559  int bin;
560  if (!blk && CONFIG_EAC3_DECODER)
562  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
563  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
564  }
565  }
566 }
567 
571 static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
572 {
573  int ch, end;
574  int got_cplchan = 0;
575  mant_groups m;
576 
577  m.b1 = m.b2 = m.b4 = 0;
578 
579  for (ch = 1; ch <= s->channels; ch++) {
580  /* transform coefficients for full-bandwidth channel */
581  decode_transform_coeffs_ch(s, blk, ch, &m);
582  /* transform coefficients for coupling channel come right after the
583  coefficients for the first coupled channel*/
584  if (s->channel_in_cpl[ch]) {
585  if (!got_cplchan) {
586  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
588  got_cplchan = 1;
589  }
590  end = s->end_freq[CPL_CH];
591  } else {
592  end = s->end_freq[ch];
593  }
594  do
595  s->fixed_coeffs[ch][end] = 0;
596  while (++end < 256);
597  }
598 
599  /* zero the dithered coefficients for appropriate channels */
600  remove_dithering(s);
601 }
602 
607 static void do_rematrixing(AC3DecodeContext *s)
608 {
609  int bnd, i;
610  int end, bndend;
611 
612  end = FFMIN(s->end_freq[1], s->end_freq[2]);
613 
614  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
615  if (s->rematrixing_flags[bnd]) {
616  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
617  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
618  int tmp0 = s->fixed_coeffs[1][i];
619  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
620  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
621  }
622  }
623  }
624 }
625 
631 static inline void do_imdct(AC3DecodeContext *s, int channels)
632 {
633  int ch;
634 
635  for (ch = 1; ch <= channels; ch++) {
636  if (s->block_switch[ch]) {
637  int i;
638  float *x = s->tmp_output + 128;
639  for (i = 0; i < 128; i++)
640  x[i] = s->transform_coeffs[ch][2 * i];
641  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
642  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
643  s->tmp_output, s->window, 128);
644  for (i = 0; i < 128; i++)
645  x[i] = s->transform_coeffs[ch][2 * i + 1];
646  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
647  } else {
648  s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
649  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
650  s->tmp_output, s->window, 128);
651  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
652  }
653  }
654 }
655 
659 static void ac3_upmix_delay(AC3DecodeContext *s)
660 {
661  int channel_data_size = sizeof(s->delay[0]);
662  switch (s->channel_mode) {
663  case AC3_CHMODE_DUALMONO:
664  case AC3_CHMODE_STEREO:
665  /* upmix mono to stereo */
666  memcpy(s->delay[1], s->delay[0], channel_data_size);
667  break;
668  case AC3_CHMODE_2F2R:
669  memset(s->delay[3], 0, channel_data_size);
670  case AC3_CHMODE_2F1R:
671  memset(s->delay[2], 0, channel_data_size);
672  break;
673  case AC3_CHMODE_3F2R:
674  memset(s->delay[4], 0, channel_data_size);
675  case AC3_CHMODE_3F1R:
676  memset(s->delay[3], 0, channel_data_size);
677  case AC3_CHMODE_3F:
678  memcpy(s->delay[2], s->delay[1], channel_data_size);
679  memset(s->delay[1], 0, channel_data_size);
680  break;
681  }
682 }
683 
700 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
701  int ecpl, int start_subband, int end_subband,
702  const uint8_t *default_band_struct,
703  int *num_bands, uint8_t *band_sizes)
704 {
705  int subbnd, bnd, n_subbands, n_bands=0;
706  uint8_t bnd_sz[22];
707  uint8_t coded_band_struct[22];
708  const uint8_t *band_struct;
709 
710  n_subbands = end_subband - start_subband;
711 
712  /* decode band structure from bitstream or use default */
713  if (!eac3 || get_bits1(gbc)) {
714  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
715  coded_band_struct[subbnd] = get_bits1(gbc);
716  }
717  band_struct = coded_band_struct;
718  } else if (!blk) {
719  band_struct = &default_band_struct[start_subband+1];
720  } else {
721  /* no change in band structure */
722  return;
723  }
724 
725  /* calculate number of bands and band sizes based on band structure.
726  note that the first 4 subbands in enhanced coupling span only 6 bins
727  instead of 12. */
728  if (num_bands || band_sizes ) {
729  n_bands = n_subbands;
730  bnd_sz[0] = ecpl ? 6 : 12;
731  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
732  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
733  if (band_struct[subbnd - 1]) {
734  n_bands--;
735  bnd_sz[bnd] += subbnd_size;
736  } else {
737  bnd_sz[++bnd] = subbnd_size;
738  }
739  }
740  }
741 
742  /* set optional output params */
743  if (num_bands)
744  *num_bands = n_bands;
745  if (band_sizes)
746  memcpy(band_sizes, bnd_sz, n_bands);
747 }
748 
749 static inline int spx_strategy(AC3DecodeContext *s, int blk)
750 {
751  GetBitContext *bc = &s->gbc;
752  int fbw_channels = s->fbw_channels;
753  int dst_start_freq, dst_end_freq, src_start_freq,
754  start_subband, end_subband, ch;
755 
756  /* determine which channels use spx */
757  if (s->channel_mode == AC3_CHMODE_MONO) {
758  s->channel_uses_spx[1] = 1;
759  } else {
760  for (ch = 1; ch <= fbw_channels; ch++)
761  s->channel_uses_spx[ch] = get_bits1(bc);
762  }
763 
764  /* get the frequency bins of the spx copy region and the spx start
765  and end subbands */
766  dst_start_freq = get_bits(bc, 2);
767  start_subband = get_bits(bc, 3) + 2;
768  if (start_subband > 7)
769  start_subband += start_subband - 7;
770  end_subband = get_bits(bc, 3) + 5;
771  if (end_subband > 7)
772  end_subband += end_subband - 7;
773  dst_start_freq = dst_start_freq * 12 + 25;
774  src_start_freq = start_subband * 12 + 25;
775  dst_end_freq = end_subband * 12 + 25;
776 
777  /* check validity of spx ranges */
778  if (start_subband >= end_subband) {
779  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
780  "range (%d >= %d)\n", start_subband, end_subband);
781  return AVERROR_INVALIDDATA;
782  }
783  if (dst_start_freq >= src_start_freq) {
784  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
785  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
786  return AVERROR_INVALIDDATA;
787  }
788 
789  s->spx_dst_start_freq = dst_start_freq;
790  s->spx_src_start_freq = src_start_freq;
791  s->spx_dst_end_freq = dst_end_freq;
792 
793  decode_band_structure(bc, blk, s->eac3, 0,
794  start_subband, end_subband,
796  &s->num_spx_bands,
797  s->spx_band_sizes);
798 
799  return 0;
800 }
801 
802 static inline void spx_coordinates(AC3DecodeContext *s)
803 {
804  GetBitContext *bc = &s->gbc;
805  int fbw_channels = s->fbw_channels;
806  int ch, bnd;
807 
808  for (ch = 1; ch <= fbw_channels; ch++) {
809  if (s->channel_uses_spx[ch]) {
810  if (s->first_spx_coords[ch] || get_bits1(bc)) {
811  float spx_blend;
812  int bin, master_spx_coord;
813 
814  s->first_spx_coords[ch] = 0;
815  spx_blend = get_bits(bc, 5) * (1.0f / 32);
816  master_spx_coord = get_bits(bc, 2) * 3;
817 
818  bin = s->spx_src_start_freq;
819  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
820  int bandsize;
821  int spx_coord_exp, spx_coord_mant;
822  float nratio, sblend, nblend, spx_coord;
823 
824  /* calculate blending factors */
825  bandsize = s->spx_band_sizes[bnd];
826  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
827  nratio = av_clipf(nratio, 0.0f, 1.0f);
828  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
829  // to give unity variance
830  sblend = sqrtf(1.0f - nratio);
831  bin += bandsize;
832 
833  /* decode spx coordinates */
834  spx_coord_exp = get_bits(bc, 4);
835  spx_coord_mant = get_bits(bc, 2);
836  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
837  else spx_coord_mant += 4;
838  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
839  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
840 
841  /* multiply noise and signal blending factors by spx coordinate */
842  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
843  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
844  }
845  }
846  } else {
847  s->first_spx_coords[ch] = 1;
848  }
849  }
850 }
851 
852 static inline int coupling_strategy(AC3DecodeContext *s, int blk,
853  uint8_t *bit_alloc_stages)
854 {
855  GetBitContext *bc = &s->gbc;
856  int fbw_channels = s->fbw_channels;
857  int channel_mode = s->channel_mode;
858  int ch;
859 
860  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
861  if (!s->eac3)
862  s->cpl_in_use[blk] = get_bits1(bc);
863  if (s->cpl_in_use[blk]) {
864  /* coupling in use */
865  int cpl_start_subband, cpl_end_subband;
866 
867  if (channel_mode < AC3_CHMODE_STEREO) {
868  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
869  return AVERROR_INVALIDDATA;
870  }
871 
872  /* check for enhanced coupling */
873  if (s->eac3 && get_bits1(bc)) {
874  /* TODO: parse enhanced coupling strategy info */
875  avpriv_request_sample(s->avctx, "Enhanced coupling");
876  return AVERROR_PATCHWELCOME;
877  }
878 
879  /* determine which channels are coupled */
880  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
881  s->channel_in_cpl[1] = 1;
882  s->channel_in_cpl[2] = 1;
883  } else {
884  for (ch = 1; ch <= fbw_channels; ch++)
885  s->channel_in_cpl[ch] = get_bits1(bc);
886  }
887 
888  /* phase flags in use */
889  if (channel_mode == AC3_CHMODE_STEREO)
890  s->phase_flags_in_use = get_bits1(bc);
891 
892  /* coupling frequency range */
893  cpl_start_subband = get_bits(bc, 4);
894  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
895  get_bits(bc, 4) + 3;
896  if (cpl_start_subband >= cpl_end_subband) {
897  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
898  cpl_start_subband, cpl_end_subband);
899  return AVERROR_INVALIDDATA;
900  }
901  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
902  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
903 
904  decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
905  cpl_end_subband,
907  &s->num_cpl_bands, s->cpl_band_sizes);
908  } else {
909  /* coupling not in use */
910  for (ch = 1; ch <= fbw_channels; ch++) {
911  s->channel_in_cpl[ch] = 0;
912  s->first_cpl_coords[ch] = 1;
913  }
914  s->first_cpl_leak = s->eac3;
915  s->phase_flags_in_use = 0;
916  }
917 
918  return 0;
919 }
920 
921 static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
922 {
923  GetBitContext *bc = &s->gbc;
924  int fbw_channels = s->fbw_channels;
925  int ch, bnd;
926  int cpl_coords_exist = 0;
927 
928  for (ch = 1; ch <= fbw_channels; ch++) {
929  if (s->channel_in_cpl[ch]) {
930  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
931  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
932  s->first_cpl_coords[ch] = 0;
933  cpl_coords_exist = 1;
934  master_cpl_coord = 3 * get_bits(bc, 2);
935  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
936  cpl_coord_exp = get_bits(bc, 4);
937  cpl_coord_mant = get_bits(bc, 4);
938  if (cpl_coord_exp == 15)
939  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
940  else
941  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
942  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
943  }
944  } else if (!blk) {
945  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
946  "be present in block 0\n");
947  return AVERROR_INVALIDDATA;
948  }
949  } else {
950  /* channel not in coupling */
951  s->first_cpl_coords[ch] = 1;
952  }
953  }
954  /* phase flags */
955  if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
956  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
957  s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
958  }
959  }
960 
961  return 0;
962 }
963 
967 static int decode_audio_block(AC3DecodeContext *s, int blk)
968 {
969  int fbw_channels = s->fbw_channels;
970  int channel_mode = s->channel_mode;
971  int i, bnd, seg, ch, ret;
972  int different_transforms;
973  int downmix_output;
974  int cpl_in_use;
975  GetBitContext *gbc = &s->gbc;
976  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
977 
978  /* block switch flags */
979  different_transforms = 0;
980  if (s->block_switch_syntax) {
981  for (ch = 1; ch <= fbw_channels; ch++) {
982  s->block_switch[ch] = get_bits1(gbc);
983  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
984  different_transforms = 1;
985  }
986  }
987 
988  /* dithering flags */
989  if (s->dither_flag_syntax) {
990  for (ch = 1; ch <= fbw_channels; ch++) {
991  s->dither_flag[ch] = get_bits1(gbc);
992  }
993  }
994 
995  /* dynamic range */
996  i = !s->channel_mode;
997  do {
998  if (get_bits1(gbc)) {
999  /* Allow asymmetric application of DRC when drc_scale > 1.
1000  Amplification of quiet sounds is enhanced */
1001  float range = dynamic_range_tab[get_bits(gbc, 8)];
1002  if (range > 1.0 || s->drc_scale <= 1.0)
1003  s->dynamic_range[i] = powf(range, s->drc_scale);
1004  else
1005  s->dynamic_range[i] = range;
1006  } else if (blk == 0) {
1007  s->dynamic_range[i] = 1.0f;
1008  }
1009  } while (i--);
1010 
1011  /* spectral extension strategy */
1012  if (s->eac3 && (!blk || get_bits1(gbc))) {
1013  s->spx_in_use = get_bits1(gbc);
1014  if (s->spx_in_use) {
1015  if ((ret = spx_strategy(s, blk)) < 0)
1016  return ret;
1017  } else {
1018  for (ch = 1; ch <= fbw_channels; ch++) {
1019  s->channel_uses_spx[ch] = 0;
1020  s->first_spx_coords[ch] = 1;
1021  }
1022  }
1023  }
1024 
1025  /* spectral extension coordinates */
1026  if (s->spx_in_use)
1027  spx_coordinates(s);
1028 
1029  /* coupling strategy */
1030  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1031  if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1032  return ret;
1033  } else if (!s->eac3) {
1034  if (!blk) {
1035  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1036  "be present in block 0\n");
1037  return AVERROR_INVALIDDATA;
1038  } else {
1039  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1040  }
1041  }
1042  cpl_in_use = s->cpl_in_use[blk];
1043 
1044  /* coupling coordinates */
1045  if (cpl_in_use) {
1046  if ((ret = coupling_coordinates(s, blk)) < 0)
1047  return ret;
1048  }
1049 
1050  /* stereo rematrixing strategy and band structure */
1051  if (channel_mode == AC3_CHMODE_STEREO) {
1052  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1053  s->num_rematrixing_bands = 4;
1054  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1055  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1056  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1057  s->num_rematrixing_bands--;
1058  }
1059  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1060  s->rematrixing_flags[bnd] = get_bits1(gbc);
1061  } else if (!blk) {
1062  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1063  "new rematrixing strategy not present in block 0\n");
1064  s->num_rematrixing_bands = 0;
1065  }
1066  }
1067 
1068  /* exponent strategies for each channel */
1069  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1070  if (!s->eac3)
1071  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1072  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1073  bit_alloc_stages[ch] = 3;
1074  }
1075 
1076  /* channel bandwidth */
1077  for (ch = 1; ch <= fbw_channels; ch++) {
1078  s->start_freq[ch] = 0;
1079  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1080  int group_size;
1081  int prev = s->end_freq[ch];
1082  if (s->channel_in_cpl[ch])
1083  s->end_freq[ch] = s->start_freq[CPL_CH];
1084  else if (s->channel_uses_spx[ch])
1085  s->end_freq[ch] = s->spx_src_start_freq;
1086  else {
1087  int bandwidth_code = get_bits(gbc, 6);
1088  if (bandwidth_code > 60) {
1089  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1090  return AVERROR_INVALIDDATA;
1091  }
1092  s->end_freq[ch] = bandwidth_code * 3 + 73;
1093  }
1094  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1095  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1096  if (blk > 0 && s->end_freq[ch] != prev)
1097  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1098  }
1099  }
1100  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1101  s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1102  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1103  }
1104 
1105  /* decode exponents for each channel */
1106  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1107  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1108  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1109  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1110  s->num_exp_groups[ch], s->dexps[ch][0],
1111  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1112  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1113  return AVERROR_INVALIDDATA;
1114  }
1115  if (ch != CPL_CH && ch != s->lfe_ch)
1116  skip_bits(gbc, 2); /* skip gainrng */
1117  }
1118  }
1119 
1120  /* bit allocation information */
1121  if (s->bit_allocation_syntax) {
1122  if (get_bits1(gbc)) {
1123  s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1124  s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1125  s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1126  s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1127  s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1128  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1129  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1130  } else if (!blk) {
1131  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1132  "be present in block 0\n");
1133  return AVERROR_INVALIDDATA;
1134  }
1135  }
1136 
1137  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1138  if (!s->eac3 || !blk) {
1139  if (s->snr_offset_strategy && get_bits1(gbc)) {
1140  int snr = 0;
1141  int csnr;
1142  csnr = (get_bits(gbc, 6) - 15) << 4;
1143  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1144  /* snr offset */
1145  if (ch == i || s->snr_offset_strategy == 2)
1146  snr = (csnr + get_bits(gbc, 4)) << 2;
1147  /* run at least last bit allocation stage if snr offset changes */
1148  if (blk && s->snr_offset[ch] != snr) {
1149  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1150  }
1151  s->snr_offset[ch] = snr;
1152 
1153  /* fast gain (normal AC-3 only) */
1154  if (!s->eac3) {
1155  int prev = s->fast_gain[ch];
1156  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1157  /* run last 2 bit allocation stages if fast gain changes */
1158  if (blk && prev != s->fast_gain[ch])
1159  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1160  }
1161  }
1162  } else if (!s->eac3 && !blk) {
1163  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1164  return AVERROR_INVALIDDATA;
1165  }
1166  }
1167 
1168  /* fast gain (E-AC-3 only) */
1169  if (s->fast_gain_syntax && get_bits1(gbc)) {
1170  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1171  int prev = s->fast_gain[ch];
1172  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1173  /* run last 2 bit allocation stages if fast gain changes */
1174  if (blk && prev != s->fast_gain[ch])
1175  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1176  }
1177  } else if (s->eac3 && !blk) {
1178  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1179  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1180  }
1181 
1182  /* E-AC-3 to AC-3 converter SNR offset */
1183  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1184  skip_bits(gbc, 10); // skip converter snr offset
1185  }
1186 
1187  /* coupling leak information */
1188  if (cpl_in_use) {
1189  if (s->first_cpl_leak || get_bits1(gbc)) {
1190  int fl = get_bits(gbc, 3);
1191  int sl = get_bits(gbc, 3);
1192  /* run last 2 bit allocation stages for coupling channel if
1193  coupling leak changes */
1194  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1195  sl != s->bit_alloc_params.cpl_slow_leak)) {
1196  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1197  }
1198  s->bit_alloc_params.cpl_fast_leak = fl;
1199  s->bit_alloc_params.cpl_slow_leak = sl;
1200  } else if (!s->eac3 && !blk) {
1201  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1202  "be present in block 0\n");
1203  return AVERROR_INVALIDDATA;
1204  }
1205  s->first_cpl_leak = 0;
1206  }
1207 
1208  /* delta bit allocation information */
1209  if (s->dba_syntax && get_bits1(gbc)) {
1210  /* delta bit allocation exists (strategy) */
1211  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1212  s->dba_mode[ch] = get_bits(gbc, 2);
1213  if (s->dba_mode[ch] == DBA_RESERVED) {
1214  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1215  return AVERROR_INVALIDDATA;
1216  }
1217  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1218  }
1219  /* channel delta offset, len and bit allocation */
1220  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1221  if (s->dba_mode[ch] == DBA_NEW) {
1222  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1223  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1224  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1225  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1226  s->dba_values[ch][seg] = get_bits(gbc, 3);
1227  }
1228  /* run last 2 bit allocation stages if new dba values */
1229  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1230  }
1231  }
1232  } else if (blk == 0) {
1233  for (ch = 0; ch <= s->channels; ch++) {
1234  s->dba_mode[ch] = DBA_NONE;
1235  }
1236  }
1237 
1238  /* Bit allocation */
1239  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1240  if (bit_alloc_stages[ch] > 2) {
1241  /* Exponent mapping into PSD and PSD integration */
1242  ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1243  s->start_freq[ch], s->end_freq[ch],
1244  s->psd[ch], s->band_psd[ch]);
1245  }
1246  if (bit_alloc_stages[ch] > 1) {
1247  /* Compute excitation function, Compute masking curve, and
1248  Apply delta bit allocation */
1249  if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1250  s->start_freq[ch], s->end_freq[ch],
1251  s->fast_gain[ch], (ch == s->lfe_ch),
1252  s->dba_mode[ch], s->dba_nsegs[ch],
1253  s->dba_offsets[ch], s->dba_lengths[ch],
1254  s->dba_values[ch], s->mask[ch])) {
1255  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1256  return AVERROR_INVALIDDATA;
1257  }
1258  }
1259  if (bit_alloc_stages[ch] > 0) {
1260  /* Compute bit allocation */
1261  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1263  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1264  s->start_freq[ch], s->end_freq[ch],
1265  s->snr_offset[ch],
1266  s->bit_alloc_params.floor,
1267  bap_tab, s->bap[ch]);
1268  }
1269  }
1270 
1271  /* unused dummy data */
1272  if (s->skip_syntax && get_bits1(gbc)) {
1273  int skipl = get_bits(gbc, 9);
1274  skip_bits_long(gbc, 8 * skipl);
1275  }
1276 
1277  /* unpack the transform coefficients
1278  this also uncouples channels if coupling is in use. */
1279  decode_transform_coeffs(s, blk);
1280 
1281  /* TODO: generate enhanced coupling coordinates and uncouple */
1282 
1283  /* recover coefficients if rematrixing is in use */
1284  if (s->channel_mode == AC3_CHMODE_STEREO)
1285  do_rematrixing(s);
1286 
1287  /* apply scaling to coefficients (headroom, dynrng) */
1288  for (ch = 1; ch <= s->channels; ch++) {
1289  float gain = 1.0 / 4194304.0f;
1290  if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1291  gain *= s->dynamic_range[2 - ch];
1292  } else {
1293  gain *= s->dynamic_range[0];
1294  }
1295  s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1296  s->fixed_coeffs[ch], gain, 256);
1297  }
1298 
1299  /* apply spectral extension to high frequency bins */
1300  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1302  }
1303 
1304  /* downmix and MDCT. order depends on whether block switching is used for
1305  any channel in this block. this is because coefficients for the long
1306  and short transforms cannot be mixed. */
1307  downmix_output = s->channels != s->out_channels &&
1308  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1309  s->fbw_channels == s->out_channels);
1310  if (different_transforms) {
1311  /* the delay samples have already been downmixed, so we upmix the delay
1312  samples in order to reconstruct all channels before downmixing. */
1313  if (s->downmixed) {
1314  s->downmixed = 0;
1315  ac3_upmix_delay(s);
1316  }
1317 
1318  do_imdct(s, s->channels);
1319 
1320  if (downmix_output) {
1321  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1322  s->out_channels, s->fbw_channels, 256);
1323  }
1324  } else {
1325  if (downmix_output) {
1326  s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1327  s->out_channels, s->fbw_channels, 256);
1328  }
1329 
1330  if (downmix_output && !s->downmixed) {
1331  s->downmixed = 1;
1332  s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1333  s->fbw_channels, 128);
1334  }
1335 
1336  do_imdct(s, s->out_channels);
1337  }
1338 
1339  return 0;
1340 }
1341 
1345 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1346  int *got_frame_ptr, AVPacket *avpkt)
1347 {
1348  AVFrame *frame = data;
1349  const uint8_t *buf = avpkt->data;
1350  int buf_size = avpkt->size;
1351  AC3DecodeContext *s = avctx->priv_data;
1352  int blk, ch, err, ret;
1353  const uint8_t *channel_map;
1354  const float *output[AC3_MAX_CHANNELS];
1355  enum AVMatrixEncoding matrix_encoding;
1356  AVDownmixInfo *downmix_info;
1357 
1358  /* copy input buffer to decoder context to avoid reading past the end
1359  of the buffer, which can be caused by a damaged input stream. */
1360  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1361  // seems to be byte-swapped AC-3
1362  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1363  s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1364  (const uint16_t *) buf, cnt);
1365  } else
1366  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1367  buf = s->input_buffer;
1368  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1369  init_get_bits(&s->gbc, buf, buf_size * 8);
1370 
1371  /* parse the syncinfo */
1372  err = parse_frame_header(s);
1373 
1374  if (err) {
1375  switch (err) {
1377  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1378  return AVERROR_INVALIDDATA;
1380  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1381  break;
1383  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1384  break;
1386  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1387  break;
1389  /* skip frame if CRC is ok. otherwise use error concealment. */
1390  /* TODO: add support for substreams and dependent frames */
1391  if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1392  av_log(avctx, AV_LOG_DEBUG,
1393  "unsupported frame type %d: skipping frame\n",
1394  s->frame_type);
1395  *got_frame_ptr = 0;
1396  return buf_size;
1397  } else {
1398  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1399  }
1400  break;
1403  break;
1404  default: // Normal AVERROR do not try to recover.
1405  *got_frame_ptr = 0;
1406  return err;
1407  }
1408  } else {
1409  /* check that reported frame size fits in input buffer */
1410  if (s->frame_size > buf_size) {
1411  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1413  } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1414  /* check for crc mismatch */
1415  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1416  s->frame_size - 2)) {
1417  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1418  if (avctx->err_recognition & AV_EF_EXPLODE)
1419  return AVERROR_INVALIDDATA;
1421  }
1422  }
1423  }
1424 
1425  /* if frame is ok, set audio parameters */
1426  if (!err) {
1427  avctx->sample_rate = s->sample_rate;
1428  avctx->bit_rate = s->bit_rate;
1429  }
1430 
1431  /* channel config */
1432  if (!err || (s->channels && s->out_channels != s->channels)) {
1433  s->out_channels = s->channels;
1434  s->output_mode = s->channel_mode;
1435  if (s->lfe_on)
1436  s->output_mode |= AC3_OUTPUT_LFEON;
1437  if (s->channels > 1 &&
1439  s->out_channels = 1;
1440  s->output_mode = AC3_CHMODE_MONO;
1441  } else if (s->channels > 2 &&
1443  s->out_channels = 2;
1444  s->output_mode = AC3_CHMODE_STEREO;
1445  }
1446 
1447  /* set downmixing coefficients if needed */
1448  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1449  s->fbw_channels == s->out_channels)) {
1450  set_downmix_coeffs(s);
1451  }
1452  } else if (!s->channels) {
1453  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1454  return AVERROR_INVALIDDATA;
1455  }
1456  avctx->channels = s->out_channels;
1457  avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1458  if (s->output_mode & AC3_OUTPUT_LFEON)
1460 
1461  /* set audio service type based on bitstream mode for AC-3 */
1462  avctx->audio_service_type = s->bitstream_mode;
1463  if (s->bitstream_mode == 0x7 && s->channels > 1)
1465 
1466  /* get output buffer */
1467  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1468  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1469  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1470  return ret;
1471  }
1472 
1473  /* decode the audio blocks */
1474  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1475  for (ch = 0; ch < s->channels; ch++) {
1476  if (ch < s->out_channels)
1477  s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1478  else
1479  s->outptr[ch] = s->output[ch];
1480  output[ch] = s->output[ch];
1481  }
1482  for (blk = 0; blk < s->num_blocks; blk++) {
1483  if (!err && decode_audio_block(s, blk)) {
1484  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1485  err = 1;
1486  }
1487  if (err)
1488  for (ch = 0; ch < s->out_channels; ch++)
1489  memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1490  for (ch = 0; ch < s->out_channels; ch++)
1491  output[ch] = s->outptr[channel_map[ch]];
1492  for (ch = 0; ch < s->out_channels; ch++)
1493  s->outptr[ch] += AC3_BLOCK_SIZE;
1494  }
1495 
1496  /* keep last block for error concealment in next frame */
1497  for (ch = 0; ch < s->out_channels; ch++)
1498  memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1499 
1500  /*
1501  * AVMatrixEncoding
1502  *
1503  * Check whether the input layout is compatible, and make sure we're not
1504  * downmixing (else the matrix encoding is no longer applicable).
1505  */
1506  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1507  if (s->channel_mode == AC3_CHMODE_STEREO &&
1508  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1509  if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1510  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1511  else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1512  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1513  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1514  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1515  switch (s->dolby_surround_ex_mode) {
1516  case AC3_DSUREXMOD_ON: // EX or PLIIx
1517  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1518  break;
1519  case AC3_DSUREXMOD_PLIIZ:
1520  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1521  break;
1522  default: // not indicated or off
1523  break;
1524  }
1525  }
1526  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1527  return ret;
1528 
1529  /* AVDownmixInfo */
1530  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1531  switch (s->preferred_downmix) {
1532  case AC3_DMIXMOD_LTRT:
1534  break;
1535  case AC3_DMIXMOD_LORO:
1537  break;
1538  case AC3_DMIXMOD_DPLII:
1540  break;
1541  default:
1543  break;
1544  }
1545  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1546  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1547  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1548  downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1549  if (s->lfe_mix_level_exists)
1550  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1551  else
1552  downmix_info->lfe_mix_level = 0.0; // -inf dB
1553  } else
1554  return AVERROR(ENOMEM);
1555 
1556  *got_frame_ptr = 1;
1557 
1558  return FFMIN(buf_size, s->frame_size);
1559 }
1560 
1565 {
1566  AC3DecodeContext *s = avctx->priv_data;
1567  ff_mdct_end(&s->imdct_512);
1568  ff_mdct_end(&s->imdct_256);
1569 
1570  return 0;
1571 }
1572 
1573 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1574 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1575 static const AVOption options[] = {
1576  { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1577  { NULL},
1578 };
1579 
1580 static const AVClass ac3_decoder_class = {
1581  .class_name = "AC3 decoder",
1582  .item_name = av_default_item_name,
1583  .option = options,
1584  .version = LIBAVUTIL_VERSION_INT,
1585 };
1586 
1588  .name = "ac3",
1589  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1590  .type = AVMEDIA_TYPE_AUDIO,
1591  .id = AV_CODEC_ID_AC3,
1592  .priv_data_size = sizeof (AC3DecodeContext),
1593  .init = ac3_decode_init,
1594  .close = ac3_decode_end,
1596  .capabilities = AV_CODEC_CAP_DR1,
1597  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1599  .priv_class = &ac3_decoder_class,
1600 };
1601 
1602 #if CONFIG_EAC3_DECODER
1603 static const AVClass eac3_decoder_class = {
1604  .class_name = "E-AC3 decoder",
1605  .item_name = av_default_item_name,
1606  .option = options,
1607  .version = LIBAVUTIL_VERSION_INT,
1608 };
1609 
1611  .name = "eac3",
1612  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1613  .type = AVMEDIA_TYPE_AUDIO,
1614  .id = AV_CODEC_ID_EAC3,
1615  .priv_data_size = sizeof (AC3DecodeContext),
1616  .init = ac3_decode_init,
1617  .close = ac3_decode_end,
1619  .capabilities = AV_CODEC_CAP_DR1,
1620  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1622  .priv_class = &eac3_decoder_class,
1623 };
1624 #endif
audio downmix medatata
uint8_t bitstream_mode
Definition: ac3.h:134
AVCodec ff_ac3_decoder
Definition: ac3dec.c:1587
float, planar
Definition: samplefmt.h:71
static int coupling_strategy(AC3DecodeContext *s, int blk, uint8_t *bit_alloc_stages)
Definition: ac3dec.c:852
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
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
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:700
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:312
AVOption.
Definition: opt.h:234
static int spx_strategy(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:749
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
Definition: vf_drawbox.c:37
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:130
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
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:187
#define CONFIG_EAC3_DECODER
Definition: config.h:743
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:221
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:54
AVDownmixInfo * av_downmix_info_update_side_data(AVFrame *frame)
Get a frame&#39;s AV_FRAME_DATA_DOWNMIX_INFO side data for editing.
Definition: downmix_info.c:24
int size
Definition: avcodec.h:1347
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:460
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:382
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
int b4
Definition: ac3dec.c:453
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, mant_groups *m)
Definition: ac3dec.c:551
#define EXP_REUSE
Definition: ac3.h:45
#define AV_CH_LAYOUT_STEREO
const uint16_t ff_ac3_slow_gain_tab[4]
Definition: ac3tab.c:288
#define blk(i)
Definition: sha.c:169
static const AVClass eac3_decoder_class
Definition: ac3dec.c:1603
AVCodec.
Definition: avcodec.h:3120
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:214
Not indicated.
Definition: downmix_info.h:45
static void spx_coordinates(AC3DecodeContext *s)
Definition: ac3dec.c:802
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:2217
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:39
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t bits
Definition: crc.c:252
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2160
uint8_t
#define av_cold
Definition: attributes.h:66
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:298
static void do_imdct(AC3DecodeContext *s, int channels)
Inverse MDCT Transform.
Definition: ac3dec.c:631
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
Definition: ac3dec.c:1564
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:1575
#define AV_CH_LOW_FREQUENCY
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:1346
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
static int b1_mantissas[32][3]
tables for ungrouping mantissas
Definition: ac3dec.c:51
uint8_t sr_shift
Definition: ac3.h:149
Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible.
Definition: downmix_info.h:48
uint8_t bitstream_id
Definition: ac3.h:133
#define LEVEL_MINUS_1POINT5DB
Definition: ac3.h:55
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
Grouped mantissas for 3-level 5-level and 11-level quantization.
Definition: ac3dec.c:447
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:89
This structure describes optional metadata relevant to a downmix procedure.
Definition: downmix_info.h:58
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
static int decode_audio_block(AC3DecodeContext *s, int blk)
Decode a single audio block from the AC-3 bitstream.
Definition: ac3dec.c:967
const uint8_t ff_ac3_fast_decay_tab[4]
Definition: ac3tab.c:284
uint8_t frame_type
Definition: ac3.h:137
#define AV_RB16
Definition: intreadwrite.h:53
#define AVERROR(e)
Definition: error.h:43
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
Decode the transform coefficients.
Definition: ac3dec.c:571
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
uint8_t sr_code
Definition: ac3.h:132
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:145
#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
AV_CODEC_FLAG_*.
Definition: avcodec.h:1503
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:124
Definition: ac3.h:66
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
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:1580
#define FFMAX(a, b)
Definition: common.h:64
#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:1345
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2203
#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
static void do_rematrixing(AC3DecodeContext *s)
Stereo rematrixing.
Definition: ac3dec.c:607
int bit_rate
the average bitrate
Definition: avcodec.h:1473
audio channel layout utility functions
int b4_mant
Definition: ac3dec.c:450
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:788
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:2670
#define FFMIN(a, b)
Definition: common.h:66
Lt/Rt 2-channel downmix, Dolby Surround compatible.
Definition: downmix_info.h:47
uint32_t bit_rate
Definition: ac3.h:151
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:212
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: avconv.c:1288
int avpriv_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)
Parse AC-3 frame header.
Definition: ac3_parser.c:50
int32_t
const uint16_t ff_ac3_fast_gain_tab[8]
Definition: ac3tab.c:300
void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
Definition: eac3dec.c:66
static int b2_mantissas[128][3]
Definition: ac3dec.c:52
Lo/Ro 2-channel downmix (Stereo).
Definition: downmix_info.h:46
int ff_eac3_parse_header(AC3DecodeContext *s)
Definition: eac3dec.c:291
#define AV_EF_EXPLODE
Definition: avcodec.h:2681
av_cold void ff_fmt_convert_init(FmtConvertContext *c, AVCodecContext *avctx)
Definition: fmtconvert.c:52
Definition: ac3.h:67
int dolby_surround_mode
Definition: ac3.h:143
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:161
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
NULL
Definition: eval.c:55
static const uint16_t dither[8][8]
Definition: vf_gradfun.c:46
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:60
int sample_rate
samples per second
Definition: avcodec.h:2152
av_default_item_name
Definition: dnxhdenc.c:55
main external API structure.
Definition: avcodec.h:1409
#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:589
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
static const float gain_levels[9]
Adjustments in dB gain.
Definition: ac3dec.c:70
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
int b1
Definition: ac3dec.c:451
Describe the class of an AVClass context structure.
Definition: log.h:34
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:259
static void set_downmix_coeffs(AC3DecodeContext *s)
Set stereo downmixing coefficients based on frame header info.
Definition: ac3dec.c:335
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:362
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:2678
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:296
static int coupling_coordinates(AC3DecodeContext *s, int blk)
Definition: ac3dec.c:921
static int ac3_parse_header(AC3DecodeContext *s)
Parse the &#39;sync info&#39; and &#39;bit stream info&#39; from the AC-3 bitstream.
Definition: ac3dec.c:214
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:146
common internal api header.
AVCodec ff_eac3_decoder
Definition: ac3dec.c:1610
#define ff_mdct_end
Definition: fft.h:152
int surround_mix_level
Surround mix level index.
Definition: ac3.h:140
int b1_mant[2]
Definition: ac3dec.c:448
int center_mix_level
Center mix level index.
Definition: ac3.h:139
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
static av_cold void ac3_tables_init(void)
Definition: ac3dec.c:120
#define PAR
Definition: apedec.c:1584
double center_mix_level
Absolute scale factor representing the nominal level of the center channel during a regular downmix...
Definition: downmix_info.h:68
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1451
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:98
static int parse_frame_header(AC3DecodeContext *s)
Common function to parse AC-3 or E-AC-3 frame header.
Definition: ac3dec.c:268
#define LEVEL_PLUS_3DB
Definition: ac3.h:53
int b2_mant[2]
Definition: ac3dec.c:449
#define OFFSET(x)
Definition: avconv_opt.c:2446
int substreamid
substream identification
Definition: ac3.h:138
int channels
number of audio channels
Definition: avcodec.h:2153
uint8_t channels
Definition: ac3.h:152
void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
Definition: eac3dec.c:198
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:419
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
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:700
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:659
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
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
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
#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:2210
static void remove_dithering(AC3DecodeContext *s)
Remove random dithering from coupling range coefficients with zero-bit mantissas for coupled channels...
Definition: ac3dec.c:538
This structure stores compressed data.
Definition: avcodec.h:1323
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:184
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:838
#define EXP_D45
Definition: ac3.h:50
for(j=16;j >0;--j)
enum AVDownmixType preferred_downmix_type
Type of downmix preferred by the mastering engineer.
Definition: downmix_info.h:62
int b2
Definition: ac3dec.c:452
#define MULH
Definition: mathops.h:42