FFmpeg  2.1.1
ac3dec.c
Go to the documentation of this file.
1 /*
2  * AC-3 Audio Decoder
3  * This code was developed as part of Google Summer of Code 2006.
4  * E-AC-3 support was added as part of Google Summer of Code 2007.
5  *
6  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
7  * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8  * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 #include <stdio.h>
28 #include <stddef.h>
29 #include <math.h>
30 #include <string.h>
31 
32 #include "libavutil/crc.h"
33 #include "libavutil/opt.h"
34 #include "internal.h"
35 #include "aac_ac3_parser.h"
36 #include "ac3_parser.h"
37 #include "ac3dec.h"
38 #include "ac3dec_data.h"
39 #include "kbdwin.h"
40 
41 /**
42  * table for ungrouping 3 values in 7 bits.
43  * used for exponents and bap=2 mantissas
44  */
46 
47 /** tables for ungrouping mantissas */
48 static int b1_mantissas[32][3];
49 static int b2_mantissas[128][3];
50 static int b3_mantissas[8];
51 static int b4_mantissas[128][2];
52 static int b5_mantissas[16];
53 
54 /**
55  * Quantization table: levels for symmetric. bits for asymmetric.
56  * reference: Table 7.18 Mapping of bap to Quantizer
57  */
58 static const uint8_t quantization_tab[16] = {
59  0, 3, 5, 7, 11, 15,
60  5, 6, 7, 8, 9, 10, 11, 12, 14, 16
61 };
62 
63 /** dynamic range table. converts codes to scale factors. */
64 static float dynamic_range_tab[256];
65 
66 /** Adjustments in dB gain */
67 static const float gain_levels[9] = {
70  LEVEL_ONE,
75  LEVEL_ZERO,
77 };
78 
79 /**
80  * Table for default stereo downmixing coefficients
81  * reference: Section 7.8.2 Downmixing Into Two Channels
82  */
83 static const uint8_t ac3_default_coeffs[8][5][2] = {
84  { { 2, 7 }, { 7, 2 }, },
85  { { 4, 4 }, },
86  { { 2, 7 }, { 7, 2 }, },
87  { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
88  { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
89  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
90  { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
91  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
92 };
93 
94 /**
95  * Symmetrical Dequantization
96  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
97  * Tables 7.19 to 7.23
98  */
99 static inline int
100 symmetric_dequant(int code, int levels)
101 {
102  return ((code - (levels >> 1)) << 24) / levels;
103 }
104 
105 /*
106  * Initialize tables at runtime.
107  */
108 static av_cold void ac3_tables_init(void)
109 {
110  int i;
111 
112  /* generate table for ungrouping 3 values in 7 bits
113  reference: Section 7.1.3 Exponent Decoding */
114  for (i = 0; i < 128; i++) {
115  ungroup_3_in_7_bits_tab[i][0] = i / 25;
116  ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
117  ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
118  }
119 
120  /* generate grouped mantissa tables
121  reference: Section 7.3.5 Ungrouping of Mantissas */
122  for (i = 0; i < 32; i++) {
123  /* bap=1 mantissas */
127  }
128  for (i = 0; i < 128; i++) {
129  /* bap=2 mantissas */
133 
134  /* bap=4 mantissas */
135  b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
136  b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
137  }
138  /* generate ungrouped mantissa tables
139  reference: Tables 7.21 and 7.23 */
140  for (i = 0; i < 7; i++) {
141  /* bap=3 mantissas */
142  b3_mantissas[i] = symmetric_dequant(i, 7);
143  }
144  for (i = 0; i < 15; i++) {
145  /* bap=5 mantissas */
146  b5_mantissas[i] = symmetric_dequant(i, 15);
147  }
148 
149  /* generate dynamic range table
150  reference: Section 7.7.1 Dynamic Range Control */
151  for (i = 0; i < 256; i++) {
152  int v = (i >> 5) - ((i >> 7) << 3) - 5;
153  dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
154  }
155 }
156 
157 /**
158  * AVCodec initialization
159  */
161 {
162  AC3DecodeContext *s = avctx->priv_data;
163  int i;
164 
165  s->avctx = avctx;
166 
168  ac3_tables_init();
169  ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
170  ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
171  ff_kbd_window_init(s->window, 5.0, 256);
172  ff_dsputil_init(&s->dsp, avctx);
175  ff_fmt_convert_init(&s->fmt_conv, avctx);
176  av_lfg_init(&s->dith_state, 0);
177 
179 
180  /* allow downmixing to stereo or mono */
181  if (avctx->channels > 0 && avctx->request_channels > 0 &&
182  avctx->request_channels < avctx->channels &&
183  avctx->request_channels <= 2) {
184  avctx->channels = avctx->request_channels;
185  }
186  s->downmixed = 1;
187 
188  for (i = 0; i < AC3_MAX_CHANNELS; i++) {
189  s->xcfptr[i] = s->transform_coeffs[i];
190  s->dlyptr[i] = s->delay[i];
191  }
192 
193  return 0;
194 }
195 
196 /**
197  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
198  * GetBitContext within AC3DecodeContext must point to
199  * the start of the synchronized AC-3 bitstream.
200  */
202 {
203  GetBitContext *gbc = &s->gbc;
204  int i;
205 
206  /* read the rest of the bsi. read twice for dual mono mode. */
207  i = !s->channel_mode;
208  do {
209  skip_bits(gbc, 5); // skip dialog normalization
210  if (get_bits1(gbc))
211  skip_bits(gbc, 8); //skip compression
212  if (get_bits1(gbc))
213  skip_bits(gbc, 8); //skip language code
214  if (get_bits1(gbc))
215  skip_bits(gbc, 7); //skip audio production information
216  } while (i--);
217 
218  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
219 
220  /* skip the timecodes (or extra bitstream information for Alternate Syntax)
221  TODO: read & use the xbsi1 downmix levels */
222  if (get_bits1(gbc))
223  skip_bits(gbc, 14); //skip timecode1 / xbsi1
224  if (get_bits1(gbc))
225  skip_bits(gbc, 14); //skip timecode2 / xbsi2
226 
227  /* skip additional bitstream info */
228  if (get_bits1(gbc)) {
229  i = get_bits(gbc, 6);
230  do {
231  skip_bits(gbc, 8);
232  } while (i--);
233  }
234 
235  return 0;
236 }
237 
238 /**
239  * Common function to parse AC-3 or E-AC-3 frame header
240  */
242 {
243  AC3HeaderInfo hdr;
244  int err;
245 
246  err = avpriv_ac3_parse_header(&s->gbc, &hdr);
247  if (err)
248  return err;
249 
250  /* get decoding parameters from header info */
253  s->channel_mode = hdr.channel_mode;
255  s->lfe_on = hdr.lfe_on;
257  s->sample_rate = hdr.sample_rate;
258  s->bit_rate = hdr.bit_rate;
259  s->channels = hdr.channels;
260  s->fbw_channels = s->channels - s->lfe_on;
261  s->lfe_ch = s->fbw_channels + 1;
262  s->frame_size = hdr.frame_size;
265  s->num_blocks = hdr.num_blocks;
266  s->frame_type = hdr.frame_type;
267  s->substreamid = hdr.substreamid;
268 
269  if (s->lfe_on) {
270  s->start_freq[s->lfe_ch] = 0;
271  s->end_freq[s->lfe_ch] = 7;
272  s->num_exp_groups[s->lfe_ch] = 2;
273  s->channel_in_cpl[s->lfe_ch] = 0;
274  }
275 
276  if (hdr.bitstream_id <= 10) {
277  s->eac3 = 0;
278  s->snr_offset_strategy = 2;
279  s->block_switch_syntax = 1;
280  s->dither_flag_syntax = 1;
281  s->bit_allocation_syntax = 1;
282  s->fast_gain_syntax = 0;
283  s->first_cpl_leak = 0;
284  s->dba_syntax = 1;
285  s->skip_syntax = 1;
286  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
287  return ac3_parse_header(s);
288  } else if (CONFIG_EAC3_DECODER) {
289  s->eac3 = 1;
290  return ff_eac3_parse_header(s);
291  } else {
292  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
293  return AVERROR(ENOSYS);
294  }
295 }
296 
297 /**
298  * Set stereo downmixing coefficients based on frame header info.
299  * reference: Section 7.8.2 Downmixing Into Two Channels
300  */
302 {
303  int i;
304  float cmix = gain_levels[s-> center_mix_level];
305  float smix = gain_levels[s->surround_mix_level];
306  float norm0, norm1;
307 
308  for (i = 0; i < s->fbw_channels; i++) {
310  s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
311  }
312  if (s->channel_mode > 1 && s->channel_mode & 1) {
313  s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
314  }
316  int nf = s->channel_mode - 2;
317  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
318  }
320  int nf = s->channel_mode - 4;
321  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
322  }
323 
324  /* renormalize */
325  norm0 = norm1 = 0.0;
326  for (i = 0; i < s->fbw_channels; i++) {
327  norm0 += s->downmix_coeffs[i][0];
328  norm1 += s->downmix_coeffs[i][1];
329  }
330  norm0 = 1.0f / norm0;
331  norm1 = 1.0f / norm1;
332  for (i = 0; i < s->fbw_channels; i++) {
333  s->downmix_coeffs[i][0] *= norm0;
334  s->downmix_coeffs[i][1] *= norm1;
335  }
336 
337  if (s->output_mode == AC3_CHMODE_MONO) {
338  for (i = 0; i < s->fbw_channels; i++)
339  s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
340  s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
341  }
342 }
343 
344 /**
345  * Decode the grouped exponents according to exponent strategy.
346  * reference: Section 7.1.3 Exponent Decoding
347  */
348 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
349  uint8_t absexp, int8_t *dexps)
350 {
351  int i, j, grp, group_size;
352  int dexp[256];
353  int expacc, prevexp;
354 
355  /* unpack groups */
356  group_size = exp_strategy + (exp_strategy == EXP_D45);
357  for (grp = 0, i = 0; grp < ngrps; grp++) {
358  expacc = get_bits(gbc, 7);
359  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
360  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
361  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
362  }
363 
364  /* convert to absolute exps and expand groups */
365  prevexp = absexp;
366  for (i = 0, j = 0; i < ngrps * 3; i++) {
367  prevexp += dexp[i] - 2;
368  if (prevexp > 24U)
369  return -1;
370  switch (group_size) {
371  case 4: dexps[j++] = prevexp;
372  dexps[j++] = prevexp;
373  case 2: dexps[j++] = prevexp;
374  case 1: dexps[j++] = prevexp;
375  }
376  }
377  return 0;
378 }
379 
380 /**
381  * Generate transform coefficients for each coupled channel in the coupling
382  * range using the coupling coefficients and coupling coordinates.
383  * reference: Section 7.4.3 Coupling Coordinate Format
384  */
386 {
387  int bin, band, ch;
388 
389  bin = s->start_freq[CPL_CH];
390  for (band = 0; band < s->num_cpl_bands; band++) {
391  int band_start = bin;
392  int band_end = bin + s->cpl_band_sizes[band];
393  for (ch = 1; ch <= s->fbw_channels; ch++) {
394  if (s->channel_in_cpl[ch]) {
395  int cpl_coord = s->cpl_coords[ch][band] << 5;
396  for (bin = band_start; bin < band_end; bin++) {
397  s->fixed_coeffs[ch][bin] =
398  MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
399  }
400  if (ch == 2 && s->phase_flags[band]) {
401  for (bin = band_start; bin < band_end; bin++)
402  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
403  }
404  }
405  }
406  bin = band_end;
407  }
408 }
409 
410 /**
411  * Grouped mantissas for 3-level 5-level and 11-level quantization
412  */
413 typedef struct {
414  int b1_mant[2];
415  int b2_mant[2];
416  int b4_mant;
417  int b1;
418  int b2;
419  int b4;
420 } mant_groups;
421 
422 /**
423  * Decode the transform coefficients for a particular channel
424  * reference: Section 7.3 Quantization and Decoding of Mantissas
425  */
427 {
428  int start_freq = s->start_freq[ch_index];
429  int end_freq = s->end_freq[ch_index];
430  uint8_t *baps = s->bap[ch_index];
431  int8_t *exps = s->dexps[ch_index];
432  int32_t *coeffs = s->fixed_coeffs[ch_index];
433  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
434  GetBitContext *gbc = &s->gbc;
435  int freq;
436 
437  for (freq = start_freq; freq < end_freq; freq++) {
438  int bap = baps[freq];
439  int mantissa;
440  switch (bap) {
441  case 0:
442  /* random noise with approximate range of -0.707 to 0.707 */
443  if (dither)
444  mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
445  else
446  mantissa = 0;
447  break;
448  case 1:
449  if (m->b1) {
450  m->b1--;
451  mantissa = m->b1_mant[m->b1];
452  } else {
453  int bits = get_bits(gbc, 5);
454  mantissa = b1_mantissas[bits][0];
455  m->b1_mant[1] = b1_mantissas[bits][1];
456  m->b1_mant[0] = b1_mantissas[bits][2];
457  m->b1 = 2;
458  }
459  break;
460  case 2:
461  if (m->b2) {
462  m->b2--;
463  mantissa = m->b2_mant[m->b2];
464  } else {
465  int bits = get_bits(gbc, 7);
466  mantissa = b2_mantissas[bits][0];
467  m->b2_mant[1] = b2_mantissas[bits][1];
468  m->b2_mant[0] = b2_mantissas[bits][2];
469  m->b2 = 2;
470  }
471  break;
472  case 3:
473  mantissa = b3_mantissas[get_bits(gbc, 3)];
474  break;
475  case 4:
476  if (m->b4) {
477  m->b4 = 0;
478  mantissa = m->b4_mant;
479  } else {
480  int bits = get_bits(gbc, 7);
481  mantissa = b4_mantissas[bits][0];
482  m->b4_mant = b4_mantissas[bits][1];
483  m->b4 = 1;
484  }
485  break;
486  case 5:
487  mantissa = b5_mantissas[get_bits(gbc, 4)];
488  break;
489  default: /* 6 to 15 */
490  /* Shift mantissa and sign-extend it. */
491  mantissa = get_sbits(gbc, quantization_tab[bap]);
492  mantissa <<= 24 - quantization_tab[bap];
493  break;
494  }
495  coeffs[freq] = mantissa >> exps[freq];
496  }
497 }
498 
499 /**
500  * Remove random dithering from coupling range coefficients with zero-bit
501  * mantissas for coupled channels which do not use dithering.
502  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
503  */
505  int ch, i;
506 
507  for (ch = 1; ch <= s->fbw_channels; ch++) {
508  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
509  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
510  if (!s->bap[CPL_CH][i])
511  s->fixed_coeffs[ch][i] = 0;
512  }
513  }
514  }
515 }
516 
518  mant_groups *m)
519 {
520  if (!s->channel_uses_aht[ch]) {
522  } else {
523  /* if AHT is used, mantissas for all blocks are encoded in the first
524  block of the frame. */
525  int bin;
526  if (!blk && CONFIG_EAC3_DECODER)
528  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
529  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
530  }
531  }
532 }
533 
534 /**
535  * Decode the transform coefficients.
536  */
538 {
539  int ch, end;
540  int got_cplchan = 0;
541  mant_groups m;
542 
543  m.b1 = m.b2 = m.b4 = 0;
544 
545  for (ch = 1; ch <= s->channels; ch++) {
546  /* transform coefficients for full-bandwidth channel */
547  decode_transform_coeffs_ch(s, blk, ch, &m);
548  /* transform coefficients for coupling channel come right after the
549  coefficients for the first coupled channel*/
550  if (s->channel_in_cpl[ch]) {
551  if (!got_cplchan) {
552  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
554  got_cplchan = 1;
555  }
556  end = s->end_freq[CPL_CH];
557  } else {
558  end = s->end_freq[ch];
559  }
560  do
561  s->fixed_coeffs[ch][end] = 0;
562  while (++end < 256);
563  }
564 
565  /* zero the dithered coefficients for appropriate channels */
566  remove_dithering(s);
567 }
568 
569 /**
570  * Stereo rematrixing.
571  * reference: Section 7.5.4 Rematrixing : Decoding Technique
572  */
574 {
575  int bnd, i;
576  int end, bndend;
577 
578  end = FFMIN(s->end_freq[1], s->end_freq[2]);
579 
580  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
581  if (s->rematrixing_flags[bnd]) {
582  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
583  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
584  int tmp0 = s->fixed_coeffs[1][i];
585  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
586  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
587  }
588  }
589  }
590 }
591 
592 /**
593  * Inverse MDCT Transform.
594  * Convert frequency domain coefficients to time-domain audio samples.
595  * reference: Section 7.9.4 Transformation Equations
596  */
597 static inline void do_imdct(AC3DecodeContext *s, int channels)
598 {
599  int ch;
600 
601  for (ch = 1; ch <= channels; ch++) {
602  if (s->block_switch[ch]) {
603  int i;
604  float *x = s->tmp_output + 128;
605  for (i = 0; i < 128; i++)
606  x[i] = s->transform_coeffs[ch][2 * i];
607  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
608  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
609  s->tmp_output, s->window, 128);
610  for (i = 0; i < 128; i++)
611  x[i] = s->transform_coeffs[ch][2 * i + 1];
612  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
613  } else {
615  s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
616  s->tmp_output, s->window, 128);
617  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
618  }
619  }
620 }
621 
622 /**
623  * Upmix delay samples from stereo to original channel layout.
624  */
626 {
627  int channel_data_size = sizeof(s->delay[0]);
628  switch (s->channel_mode) {
629  case AC3_CHMODE_DUALMONO:
630  case AC3_CHMODE_STEREO:
631  /* upmix mono to stereo */
632  memcpy(s->delay[1], s->delay[0], channel_data_size);
633  break;
634  case AC3_CHMODE_2F2R:
635  memset(s->delay[3], 0, channel_data_size);
636  case AC3_CHMODE_2F1R:
637  memset(s->delay[2], 0, channel_data_size);
638  break;
639  case AC3_CHMODE_3F2R:
640  memset(s->delay[4], 0, channel_data_size);
641  case AC3_CHMODE_3F1R:
642  memset(s->delay[3], 0, channel_data_size);
643  case AC3_CHMODE_3F:
644  memcpy(s->delay[2], s->delay[1], channel_data_size);
645  memset(s->delay[1], 0, channel_data_size);
646  break;
647  }
648 }
649 
650 /**
651  * Decode band structure for coupling, spectral extension, or enhanced coupling.
652  * The band structure defines how many subbands are in each band. For each
653  * subband in the range, 1 means it is combined with the previous band, and 0
654  * means that it starts a new band.
655  *
656  * @param[in] gbc bit reader context
657  * @param[in] blk block number
658  * @param[in] eac3 flag to indicate E-AC-3
659  * @param[in] ecpl flag to indicate enhanced coupling
660  * @param[in] start_subband subband number for start of range
661  * @param[in] end_subband subband number for end of range
662  * @param[in] default_band_struct default band structure table
663  * @param[out] num_bands number of bands (optionally NULL)
664  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
665  */
666 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
667  int ecpl, int start_subband, int end_subband,
668  const uint8_t *default_band_struct,
669  int *num_bands, uint8_t *band_sizes)
670 {
671  int subbnd, bnd, n_subbands, n_bands=0;
672  uint8_t bnd_sz[22];
673  uint8_t coded_band_struct[22];
674  const uint8_t *band_struct;
675 
676  n_subbands = end_subband - start_subband;
677 
678  /* decode band structure from bitstream or use default */
679  if (!eac3 || get_bits1(gbc)) {
680  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
681  coded_band_struct[subbnd] = get_bits1(gbc);
682  }
683  band_struct = coded_band_struct;
684  } else if (!blk) {
685  band_struct = &default_band_struct[start_subband+1];
686  } else {
687  /* no change in band structure */
688  return;
689  }
690 
691  /* calculate number of bands and band sizes based on band structure.
692  note that the first 4 subbands in enhanced coupling span only 6 bins
693  instead of 12. */
694  if (num_bands || band_sizes ) {
695  n_bands = n_subbands;
696  bnd_sz[0] = ecpl ? 6 : 12;
697  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
698  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
699  if (band_struct[subbnd - 1]) {
700  n_bands--;
701  bnd_sz[bnd] += subbnd_size;
702  } else {
703  bnd_sz[++bnd] = subbnd_size;
704  }
705  }
706  }
707 
708  /* set optional output params */
709  if (num_bands)
710  *num_bands = n_bands;
711  if (band_sizes)
712  memcpy(band_sizes, bnd_sz, n_bands);
713 }
714 
715 /**
716  * Decode a single audio block from the AC-3 bitstream.
717  */
719 {
720  int fbw_channels = s->fbw_channels;
721  int channel_mode = s->channel_mode;
722  int i, bnd, seg, ch;
723  int different_transforms;
724  int downmix_output;
725  int cpl_in_use;
726  GetBitContext *gbc = &s->gbc;
727  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
728 
729  /* block switch flags */
730  different_transforms = 0;
731  if (s->block_switch_syntax) {
732  for (ch = 1; ch <= fbw_channels; ch++) {
733  s->block_switch[ch] = get_bits1(gbc);
734  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
735  different_transforms = 1;
736  }
737  }
738 
739  /* dithering flags */
740  if (s->dither_flag_syntax) {
741  for (ch = 1; ch <= fbw_channels; ch++) {
742  s->dither_flag[ch] = get_bits1(gbc);
743  }
744  }
745 
746  /* dynamic range */
747  i = !s->channel_mode;
748  do {
749  if (get_bits1(gbc)) {
750  s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
751  s->drc_scale) + 1.0;
752  } else if (blk == 0) {
753  s->dynamic_range[i] = 1.0f;
754  }
755  } while (i--);
756 
757  /* spectral extension strategy */
758  if (s->eac3 && (!blk || get_bits1(gbc))) {
759  s->spx_in_use = get_bits1(gbc);
760  if (s->spx_in_use) {
761  int dst_start_freq, dst_end_freq, src_start_freq,
762  start_subband, end_subband;
763 
764  /* determine which channels use spx */
765  if (s->channel_mode == AC3_CHMODE_MONO) {
766  s->channel_uses_spx[1] = 1;
767  } else {
768  for (ch = 1; ch <= fbw_channels; ch++)
769  s->channel_uses_spx[ch] = get_bits1(gbc);
770  }
771 
772  /* get the frequency bins of the spx copy region and the spx start
773  and end subbands */
774  dst_start_freq = get_bits(gbc, 2);
775  start_subband = get_bits(gbc, 3) + 2;
776  if (start_subband > 7)
777  start_subband += start_subband - 7;
778  end_subband = get_bits(gbc, 3) + 5;
779  if (end_subband > 7)
780  end_subband += end_subband - 7;
781  dst_start_freq = dst_start_freq * 12 + 25;
782  src_start_freq = start_subband * 12 + 25;
783  dst_end_freq = end_subband * 12 + 25;
784 
785  /* check validity of spx ranges */
786  if (start_subband >= end_subband) {
787  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
788  "range (%d >= %d)\n", start_subband, end_subband);
789  return AVERROR_INVALIDDATA;
790  }
791  if (dst_start_freq >= src_start_freq) {
792  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
793  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
794  return AVERROR_INVALIDDATA;
795  }
796 
797  s->spx_dst_start_freq = dst_start_freq;
798  s->spx_src_start_freq = src_start_freq;
799  s->spx_dst_end_freq = dst_end_freq;
800 
801  decode_band_structure(gbc, blk, s->eac3, 0,
802  start_subband, end_subband,
804  &s->num_spx_bands,
805  s->spx_band_sizes);
806  } else {
807  for (ch = 1; ch <= fbw_channels; ch++) {
808  s->channel_uses_spx[ch] = 0;
809  s->first_spx_coords[ch] = 1;
810  }
811  }
812  }
813 
814  /* spectral extension coordinates */
815  if (s->spx_in_use) {
816  for (ch = 1; ch <= fbw_channels; ch++) {
817  if (s->channel_uses_spx[ch]) {
818  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
819  float spx_blend;
820  int bin, master_spx_coord;
821 
822  s->first_spx_coords[ch] = 0;
823  spx_blend = get_bits(gbc, 5) * (1.0f/32);
824  master_spx_coord = get_bits(gbc, 2) * 3;
825 
826  bin = s->spx_src_start_freq;
827  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
828  int bandsize;
829  int spx_coord_exp, spx_coord_mant;
830  float nratio, sblend, nblend, spx_coord;
831 
832  /* calculate blending factors */
833  bandsize = s->spx_band_sizes[bnd];
834  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
835  nratio = av_clipf(nratio, 0.0f, 1.0f);
836  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
837  // to give unity variance
838  sblend = sqrtf(1.0f - nratio);
839  bin += bandsize;
840 
841  /* decode spx coordinates */
842  spx_coord_exp = get_bits(gbc, 4);
843  spx_coord_mant = get_bits(gbc, 2);
844  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
845  else spx_coord_mant += 4;
846  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
847  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
848 
849  /* multiply noise and signal blending factors by spx coordinate */
850  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
851  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
852  }
853  }
854  } else {
855  s->first_spx_coords[ch] = 1;
856  }
857  }
858  }
859 
860  /* coupling strategy */
861  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
862  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
863  if (!s->eac3)
864  s->cpl_in_use[blk] = get_bits1(gbc);
865  if (s->cpl_in_use[blk]) {
866  /* coupling in use */
867  int cpl_start_subband, cpl_end_subband;
868 
869  if (channel_mode < AC3_CHMODE_STEREO) {
870  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
871  return AVERROR_INVALIDDATA;
872  }
873 
874  /* check for enhanced coupling */
875  if (s->eac3 && get_bits1(gbc)) {
876  /* TODO: parse enhanced coupling strategy info */
877  avpriv_request_sample(s->avctx, "Enhanced coupling");
878  return AVERROR_PATCHWELCOME;
879  }
880 
881  /* determine which channels are coupled */
882  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
883  s->channel_in_cpl[1] = 1;
884  s->channel_in_cpl[2] = 1;
885  } else {
886  for (ch = 1; ch <= fbw_channels; ch++)
887  s->channel_in_cpl[ch] = get_bits1(gbc);
888  }
889 
890  /* phase flags in use */
891  if (channel_mode == AC3_CHMODE_STEREO)
892  s->phase_flags_in_use = get_bits1(gbc);
893 
894  /* coupling frequency range */
895  cpl_start_subband = get_bits(gbc, 4);
896  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
897  get_bits(gbc, 4) + 3;
898  if (cpl_start_subband >= cpl_end_subband) {
899  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
900  cpl_start_subband, cpl_end_subband);
901  return AVERROR_INVALIDDATA;
902  }
903  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
904  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
905 
906  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
907  cpl_end_subband,
909  &s->num_cpl_bands, s->cpl_band_sizes);
910  } else {
911  /* coupling not in use */
912  for (ch = 1; ch <= fbw_channels; ch++) {
913  s->channel_in_cpl[ch] = 0;
914  s->first_cpl_coords[ch] = 1;
915  }
916  s->first_cpl_leak = s->eac3;
917  s->phase_flags_in_use = 0;
918  }
919  } else if (!s->eac3) {
920  if (!blk) {
921  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
922  "be present in block 0\n");
923  return AVERROR_INVALIDDATA;
924  } else {
925  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
926  }
927  }
928  cpl_in_use = s->cpl_in_use[blk];
929 
930  /* coupling coordinates */
931  if (cpl_in_use) {
932  int cpl_coords_exist = 0;
933 
934  for (ch = 1; ch <= fbw_channels; ch++) {
935  if (s->channel_in_cpl[ch]) {
936  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
937  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
938  s->first_cpl_coords[ch] = 0;
939  cpl_coords_exist = 1;
940  master_cpl_coord = 3 * get_bits(gbc, 2);
941  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
942  cpl_coord_exp = get_bits(gbc, 4);
943  cpl_coord_mant = get_bits(gbc, 4);
944  if (cpl_coord_exp == 15)
945  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
946  else
947  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
948  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
949  }
950  } else if (!blk) {
951  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
952  "be present in block 0\n");
953  return AVERROR_INVALIDDATA;
954  }
955  } else {
956  /* channel not in coupling */
957  s->first_cpl_coords[ch] = 1;
958  }
959  }
960  /* phase flags */
961  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
962  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
963  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
964  }
965  }
966  }
967 
968  /* stereo rematrixing strategy and band structure */
969  if (channel_mode == AC3_CHMODE_STEREO) {
970  if ((s->eac3 && !blk) || get_bits1(gbc)) {
971  s->num_rematrixing_bands = 4;
972  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
973  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
974  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
976  }
977  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
978  s->rematrixing_flags[bnd] = get_bits1(gbc);
979  } else if (!blk) {
980  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
981  "new rematrixing strategy not present in block 0\n");
982  s->num_rematrixing_bands = 0;
983  }
984  }
985 
986  /* exponent strategies for each channel */
987  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
988  if (!s->eac3)
989  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
990  if (s->exp_strategy[blk][ch] != EXP_REUSE)
991  bit_alloc_stages[ch] = 3;
992  }
993 
994  /* channel bandwidth */
995  for (ch = 1; ch <= fbw_channels; ch++) {
996  s->start_freq[ch] = 0;
997  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
998  int group_size;
999  int prev = s->end_freq[ch];
1000  if (s->channel_in_cpl[ch])
1001  s->end_freq[ch] = s->start_freq[CPL_CH];
1002  else if (s->channel_uses_spx[ch])
1003  s->end_freq[ch] = s->spx_src_start_freq;
1004  else {
1005  int bandwidth_code = get_bits(gbc, 6);
1006  if (bandwidth_code > 60) {
1007  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1008  return AVERROR_INVALIDDATA;
1009  }
1010  s->end_freq[ch] = bandwidth_code * 3 + 73;
1011  }
1012  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1013  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1014  if (blk > 0 && s->end_freq[ch] != prev)
1015  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1016  }
1017  }
1018  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1020  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1021  }
1022 
1023  /* decode exponents for each channel */
1024  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1025  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1026  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1027  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1028  s->num_exp_groups[ch], s->dexps[ch][0],
1029  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1030  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1031  return AVERROR_INVALIDDATA;
1032  }
1033  if (ch != CPL_CH && ch != s->lfe_ch)
1034  skip_bits(gbc, 2); /* skip gainrng */
1035  }
1036  }
1037 
1038  /* bit allocation information */
1039  if (s->bit_allocation_syntax) {
1040  if (get_bits1(gbc)) {
1046  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1047  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1048  } else if (!blk) {
1049  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1050  "be present in block 0\n");
1051  return AVERROR_INVALIDDATA;
1052  }
1053  }
1054 
1055  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1056  if (!s->eac3 || !blk) {
1057  if (s->snr_offset_strategy && get_bits1(gbc)) {
1058  int snr = 0;
1059  int csnr;
1060  csnr = (get_bits(gbc, 6) - 15) << 4;
1061  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1062  /* snr offset */
1063  if (ch == i || s->snr_offset_strategy == 2)
1064  snr = (csnr + get_bits(gbc, 4)) << 2;
1065  /* run at least last bit allocation stage if snr offset changes */
1066  if (blk && s->snr_offset[ch] != snr) {
1067  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1068  }
1069  s->snr_offset[ch] = snr;
1070 
1071  /* fast gain (normal AC-3 only) */
1072  if (!s->eac3) {
1073  int prev = s->fast_gain[ch];
1074  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1075  /* run last 2 bit allocation stages if fast gain changes */
1076  if (blk && prev != s->fast_gain[ch])
1077  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1078  }
1079  }
1080  } else if (!s->eac3 && !blk) {
1081  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1082  return AVERROR_INVALIDDATA;
1083  }
1084  }
1085 
1086  /* fast gain (E-AC-3 only) */
1087  if (s->fast_gain_syntax && get_bits1(gbc)) {
1088  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1089  int prev = s->fast_gain[ch];
1090  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1091  /* run last 2 bit allocation stages if fast gain changes */
1092  if (blk && prev != s->fast_gain[ch])
1093  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1094  }
1095  } else if (s->eac3 && !blk) {
1096  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1097  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1098  }
1099 
1100  /* E-AC-3 to AC-3 converter SNR offset */
1101  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1102  skip_bits(gbc, 10); // skip converter snr offset
1103  }
1104 
1105  /* coupling leak information */
1106  if (cpl_in_use) {
1107  if (s->first_cpl_leak || get_bits1(gbc)) {
1108  int fl = get_bits(gbc, 3);
1109  int sl = get_bits(gbc, 3);
1110  /* run last 2 bit allocation stages for coupling channel if
1111  coupling leak changes */
1112  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1113  sl != s->bit_alloc_params.cpl_slow_leak)) {
1114  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1115  }
1118  } else if (!s->eac3 && !blk) {
1119  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1120  "be present in block 0\n");
1121  return AVERROR_INVALIDDATA;
1122  }
1123  s->first_cpl_leak = 0;
1124  }
1125 
1126  /* delta bit allocation information */
1127  if (s->dba_syntax && get_bits1(gbc)) {
1128  /* delta bit allocation exists (strategy) */
1129  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1130  s->dba_mode[ch] = get_bits(gbc, 2);
1131  if (s->dba_mode[ch] == DBA_RESERVED) {
1132  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1133  return AVERROR_INVALIDDATA;
1134  }
1135  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1136  }
1137  /* channel delta offset, len and bit allocation */
1138  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1139  if (s->dba_mode[ch] == DBA_NEW) {
1140  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1141  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1142  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1143  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1144  s->dba_values[ch][seg] = get_bits(gbc, 3);
1145  }
1146  /* run last 2 bit allocation stages if new dba values */
1147  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1148  }
1149  }
1150  } else if (blk == 0) {
1151  for (ch = 0; ch <= s->channels; ch++) {
1152  s->dba_mode[ch] = DBA_NONE;
1153  }
1154  }
1155 
1156  /* Bit allocation */
1157  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1158  if (bit_alloc_stages[ch] > 2) {
1159  /* Exponent mapping into PSD and PSD integration */
1161  s->start_freq[ch], s->end_freq[ch],
1162  s->psd[ch], s->band_psd[ch]);
1163  }
1164  if (bit_alloc_stages[ch] > 1) {
1165  /* Compute excitation function, Compute masking curve, and
1166  Apply delta bit allocation */
1168  s->start_freq[ch], s->end_freq[ch],
1169  s->fast_gain[ch], (ch == s->lfe_ch),
1170  s->dba_mode[ch], s->dba_nsegs[ch],
1171  s->dba_offsets[ch], s->dba_lengths[ch],
1172  s->dba_values[ch], s->mask[ch])) {
1173  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1174  return AVERROR_INVALIDDATA;
1175  }
1176  }
1177  if (bit_alloc_stages[ch] > 0) {
1178  /* Compute bit allocation */
1179  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1181  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1182  s->start_freq[ch], s->end_freq[ch],
1183  s->snr_offset[ch],
1185  bap_tab, s->bap[ch]);
1186  }
1187  }
1188 
1189  /* unused dummy data */
1190  if (s->skip_syntax && get_bits1(gbc)) {
1191  int skipl = get_bits(gbc, 9);
1192  while (skipl--)
1193  skip_bits(gbc, 8);
1194  }
1195 
1196  /* unpack the transform coefficients
1197  this also uncouples channels if coupling is in use. */
1198  decode_transform_coeffs(s, blk);
1199 
1200  /* TODO: generate enhanced coupling coordinates and uncouple */
1201 
1202  /* recover coefficients if rematrixing is in use */
1203  if (s->channel_mode == AC3_CHMODE_STEREO)
1204  do_rematrixing(s);
1205 
1206  /* apply scaling to coefficients (headroom, dynrng) */
1207  for (ch = 1; ch <= s->channels; ch++) {
1208  float gain = 1.0 / 4194304.0f;
1209  if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1210  gain *= s->dynamic_range[2 - ch];
1211  } else {
1212  gain *= s->dynamic_range[0];
1213  }
1215  s->fixed_coeffs[ch], gain, 256);
1216  }
1217 
1218  /* apply spectral extension to high frequency bins */
1219  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1221  }
1222 
1223  /* downmix and MDCT. order depends on whether block switching is used for
1224  any channel in this block. this is because coefficients for the long
1225  and short transforms cannot be mixed. */
1226  downmix_output = s->channels != s->out_channels &&
1227  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1228  s->fbw_channels == s->out_channels);
1229  if (different_transforms) {
1230  /* the delay samples have already been downmixed, so we upmix the delay
1231  samples in order to reconstruct all channels before downmixing. */
1232  if (s->downmixed) {
1233  s->downmixed = 0;
1234  ac3_upmix_delay(s);
1235  }
1236 
1237  do_imdct(s, s->channels);
1238 
1239  if (downmix_output) {
1240  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1241  s->out_channels, s->fbw_channels, 256);
1242  }
1243  } else {
1244  if (downmix_output) {
1245  s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1246  s->out_channels, s->fbw_channels, 256);
1247  }
1248 
1249  if (downmix_output && !s->downmixed) {
1250  s->downmixed = 1;
1252  s->fbw_channels, 128);
1253  }
1254 
1255  do_imdct(s, s->out_channels);
1256  }
1257 
1258  return 0;
1259 }
1260 
1261 /**
1262  * Decode a single AC-3 frame.
1263  */
1264 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1265  int *got_frame_ptr, AVPacket *avpkt)
1266 {
1267  AVFrame *frame = data;
1268  const uint8_t *buf = avpkt->data;
1269  int buf_size = avpkt->size;
1270  AC3DecodeContext *s = avctx->priv_data;
1271  int blk, ch, err, ret;
1272  const uint8_t *channel_map;
1273  const float *output[AC3_MAX_CHANNELS];
1274 
1275  /* copy input buffer to decoder context to avoid reading past the end
1276  of the buffer, which can be caused by a damaged input stream. */
1277  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1278  // seems to be byte-swapped AC-3
1279  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1280  s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1281  } else
1282  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1283  buf = s->input_buffer;
1284  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1285  init_get_bits(&s->gbc, buf, buf_size * 8);
1286 
1287  /* parse the syncinfo */
1288  err = parse_frame_header(s);
1289 
1290  if (err) {
1291  switch (err) {
1293  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1294  return AVERROR_INVALIDDATA;
1296  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1297  break;
1299  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1300  break;
1302  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1303  break;
1305  /* skip frame if CRC is ok. otherwise use error concealment. */
1306  /* TODO: add support for substreams and dependent frames */
1308  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1309  "skipping frame\n");
1310  *got_frame_ptr = 0;
1311  return buf_size;
1312  } else {
1313  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1314  }
1315  break;
1318  break;
1319  default: // Normal AVERROR do not try to recover.
1320  *got_frame_ptr = 0;
1321  return err;
1322  }
1323  } else {
1324  /* check that reported frame size fits in input buffer */
1325  if (s->frame_size > buf_size) {
1326  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1328  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1329  /* check for crc mismatch */
1330  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1331  s->frame_size - 2)) {
1332  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1334  }
1335  }
1336  }
1337 
1338  /* if frame is ok, set audio parameters */
1339  if (!err) {
1340  avctx->sample_rate = s->sample_rate;
1341  avctx->bit_rate = s->bit_rate;
1342  }
1343 
1344  /* channel config */
1345  if (!err || (s->channels && s->out_channels != s->channels)) {
1346  s->out_channels = s->channels;
1347  s->output_mode = s->channel_mode;
1348  if (s->lfe_on)
1350  if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1351  avctx->request_channels < s->channels) {
1352  s->out_channels = avctx->request_channels;
1355  }
1356  avctx->channels = s->out_channels;
1357  avctx->channel_layout = s->channel_layout;
1358 
1359  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1363  /* set downmixing coefficients if needed */
1364  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1365  s->fbw_channels == s->out_channels)) {
1366  set_downmix_coeffs(s);
1367  }
1368  } else if (!s->channels) {
1369  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1370  return AVERROR_INVALIDDATA;
1371  }
1372  avctx->channels = s->out_channels;
1373 
1374  /* set audio service type based on bitstream mode for AC-3 */
1375  avctx->audio_service_type = s->bitstream_mode;
1376  if (s->bitstream_mode == 0x7 && s->channels > 1)
1378 
1379  /* get output buffer */
1380  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1381  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1382  return ret;
1383 
1384  /* decode the audio blocks */
1385  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1386  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1387  output[ch] = s->output[ch];
1388  s->outptr[ch] = s->output[ch];
1389  }
1390  for (ch = 0; ch < s->channels; ch++) {
1391  if (ch < s->out_channels)
1392  s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1393  }
1394  for (blk = 0; blk < s->num_blocks; blk++) {
1395  if (!err && decode_audio_block(s, blk)) {
1396  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1397  err = 1;
1398  }
1399  if (err)
1400  for (ch = 0; ch < s->out_channels; ch++)
1401  memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1402  for (ch = 0; ch < s->out_channels; ch++)
1403  output[ch] = s->outptr[channel_map[ch]];
1404  for (ch = 0; ch < s->out_channels; ch++) {
1405  if (!ch || channel_map[ch])
1406  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1407  }
1408  }
1409 
1411 
1412  /* keep last block for error concealment in next frame */
1413  for (ch = 0; ch < s->out_channels; ch++)
1414  memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1415 
1416  *got_frame_ptr = 1;
1417 
1418  return FFMIN(buf_size, s->frame_size);
1419 }
1420 
1421 /**
1422  * Uninitialize the AC-3 decoder.
1423  */
1425 {
1426  AC3DecodeContext *s = avctx->priv_data;
1427  ff_mdct_end(&s->imdct_512);
1428  ff_mdct_end(&s->imdct_256);
1429 
1430  return 0;
1431 }
1432 
1433 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1434 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1435 static const AVOption options[] = {
1436  { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1437 
1438 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1439 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1440 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1441 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1442 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1443 
1444  { NULL},
1445 };
1446 
1447 static const AVClass ac3_decoder_class = {
1448  .class_name = "AC3 decoder",
1449  .item_name = av_default_item_name,
1450  .option = options,
1451  .version = LIBAVUTIL_VERSION_INT,
1452 };
1453 
1455  .name = "ac3",
1456  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1457  .type = AVMEDIA_TYPE_AUDIO,
1458  .id = AV_CODEC_ID_AC3,
1459  .priv_data_size = sizeof (AC3DecodeContext),
1460  .init = ac3_decode_init,
1461  .close = ac3_decode_end,
1463  .capabilities = CODEC_CAP_DR1,
1464  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1466  .priv_class = &ac3_decoder_class,
1467 };
1468 
1469 #if CONFIG_EAC3_DECODER
1470 static const AVClass eac3_decoder_class = {
1471  .class_name = "E-AC3 decoder",
1472  .item_name = av_default_item_name,
1473  .option = options,
1474  .version = LIBAVUTIL_VERSION_INT,
1475 };
1476 
1477 AVCodec ff_eac3_decoder = {
1478  .name = "eac3",
1479  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1480  .type = AVMEDIA_TYPE_AUDIO,
1481  .id = AV_CODEC_ID_EAC3,
1482  .priv_data_size = sizeof (AC3DecodeContext),
1483  .init = ac3_decode_init,
1484  .close = ac3_decode_end,
1486  .capabilities = CODEC_CAP_DR1,
1487  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1489  .priv_class = &eac3_decoder_class,
1490 };
1491 #endif
uint8_t bitstream_mode
Definition: ac3.h:104
AVCodec ff_ac3_decoder
Definition: ac3dec.c:1454
uint64_t channel_layout
Definition: ac3.h:123
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:83
int dba_nsegs[AC3_MAX_CHANNELS]
number of delta segments
Definition: ac3dec.h:183
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2678
float v
const char * s
Definition: avisynth_c.h:668
#define AVERROR_PATCHWELCOME
float * dlyptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:209
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:306
int16_t psd[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
scaled exponents
Definition: ac3dec.h:179
int spx_in_use
spectral extension in use (spxinu)
Definition: ac3dec.h:123
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:666
AVOption.
Definition: opt.h:253
uint8_t dba_offsets[AC3_MAX_CHANNELS][8]
delta segment offsets
Definition: ac3dec.h:184
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:190
int16_t mask[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
masking curve values
Definition: ac3dec.h:181
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:255
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: avcodec.h:4153
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
Definition: kbdwin.c:26
#define LIBAVUTIL_VERSION_INT
Definition: avcodec.h:820
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:1926
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVFloatDSPContext fdsp
Definition: ac3dec.h:202
#define CONFIG_EAC3_DECODER
Definition: config.h:688
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:436
av_cold void ff_ac3_common_init(void)
Initialize some tables.
Definition: ac3.c:220
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:56
int size
Definition: avcodec.h:1064
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:426
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:348
int channels
number of total channels
Definition: ac3dec.h:144
int b4
Definition: ac3dec.c:419
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
int spx_dst_end_freq
spx end frequency bin
Definition: ac3dec.h:127
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, mant_groups *m)
Definition: ac3dec.c:517
#define EXP_REUSE
Definition: ac3.h:47
int exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS]
exponent strategies (expstr)
Definition: ac3dec.h:170
float dynamic_range[2]
dynamic range
Definition: ac3dec.h:153
int lfe_on
lfe channel in use
Definition: ac3dec.h:85
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:134
int block_switch[AC3_MAX_CHANNELS]
block switch flags (blksw)
Definition: ac3dec.h:195
#define blk(i)
Definition: sha.c:185
float * xcfptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:208
int dba_syntax
delta bit allocation syntax enabled (dbaflde)
Definition: ac3dec.h:104
AVCodec.
Definition: avcodec.h:2922
#define av_cold
Definition: avcodec.h:653
int spx_src_start_freq
spx start frequency bin
Definition: ac3dec.h:126
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:240
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3dec.h:115
#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:1948
float downmix_coeffs[AC3_MAX_CHANNELS][2]
stereo downmix coefficients
Definition: ac3dec.h:146
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
#define AV_RB16(x)
Definition: intreadwrite.h:232
const char * av_default_item_name(void *ctx)
Return the context name.
Definition: log.c:145
uint8_t bits
Definition: crc.c:260
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1881
float ltrt_center_mix_level
Definition: ac3dec.h:93
uint8_t
int first_cpl_coords[AC3_MAX_CHANNELS]
first coupling coordinates states (firstcplcos)
Definition: ac3dec.h:117
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:55
uint8_t lfe_on
Definition: ac3.h:106
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
static void do_imdct(AC3DecodeContext *s, int channels)
Inverse MDCT Transform.
Definition: ac3dec.c:597
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
Definition: ac3dec.c:1424
static uint8_t ungroup_3_in_7_bits_tab[128][3]
table for ungrouping 3 values in 7 bits.
Definition: ac3dec.c:45
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
float output[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
output after imdct transform and windowing
Definition: ac3dec.h:217
int num_rematrixing_bands
number of rematrixing bands (nrematbnd)
Definition: ac3dec.h:163
int fast_gain[AC3_MAX_CHANNELS]
fast gain values/SMR&#39;s (fgain)
Definition: ac3dec.h:177
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:742
float ltrt_surround_mix_level
Definition: ac3dec.h:94
const char data[16]
Definition: mxf.c:68
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:118
static int b1_mantissas[32][3]
tables for ungrouping mantissas
Definition: ac3dec.c:48
int num_exp_groups[AC3_MAX_CHANNELS]
Number of exponent groups (nexpgrp)
Definition: ac3dec.h:168
uint8_t sr_shift
Definition: ac3.h:118
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:714
uint8_t bitstream_id
Definition: ac3.h:103
#define LEVEL_MINUS_1POINT5DB
Definition: ac3.h:57
float delay[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
delay - added to the next block
Definition: ac3dec.h:214
int bit_allocation_syntax
bit allocation model syntax enabled (bamode)
Definition: ac3dec.h:102
int phase_flags_in_use
phase flags in use (phsflginu)
Definition: ac3dec.h:112
const OptionDef options[]
Definition: ffserver.c:4682
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:413
static AVFrame * frame
Definition: demuxing.c:51
int phase_flags[AC3_MAX_CPL_BANDS]
phase flags (phsflg)
Definition: ac3dec.h:113
int out_channels
number of output channels
Definition: ac3dec.h:149
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:87
#define U(x)
Definition: vp56_arith.h:37
int substreamid
substream identification
Definition: ac3dec.h:77
FFTContext imdct_256
for 256 sample IMDCT
Definition: ac3dec.h:197
DSPContext dsp
for optimization
Definition: ac3dec.h:201
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
static int decode_audio_block(AC3DecodeContext *s, int blk)
Decode a single audio block from the AC-3 bitstream.
Definition: ac3dec.c:718
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: dsputil.h:206
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:107
float * outptr[AC3_MAX_CHANNELS]
Definition: ac3dec.h:207
unsigned m
Definition: audioconvert.c:186
int lfe_ch
index of LFE channel
Definition: ac3dec.h:145
uint8_t first_spx_coords[AC3_MAX_CHANNELS]
first spx coordinates states (firstspxcos)
Definition: ac3dec.h:132
AC3BitAllocParameters bit_alloc_params
bit allocation parameters
Definition: ac3dec.h:174
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
Decode the transform coefficients.
Definition: ac3dec.c:537
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:151
#define PAR
Definition: ac3dec.c:1434
uint8_t sr_code
Definition: ac3.h:102
static const uint8_t dither[8][8]
Definition: vf_fspp.c:78
AC3DSPContext ac3dsp
Definition: ac3dec.h:203
#define LEVEL_MINUS_9DB
Definition: ac3.h:61
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:31
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1234
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:68
float loro_center_mix_level
Definition: ac3dec.h:95
Coded AC-3 header values up to the lfeon element, plus derived values.
Definition: ac3.h:96
#define ff_mdct_init
Definition: fft.h:160
uint16_t sample_rate
Definition: ac3.h:119
static const AVClass ac3_decoder_class
Definition: ac3dec.c:1447
#define LEVEL_MINUS_3DB
Definition: ac3.h:58
static int ac3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single AC-3 frame.
Definition: ac3dec.c:1264
int block_switch_syntax
block switch syntax enabled (blkswe)
Definition: ac3dec.h:100
int fast_gain_syntax
fast gain codes enabled (frmfgaincode)
Definition: ac3dec.h:103
int16_t band_psd[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
interpolated exponents
Definition: ac3dec.h:180
uint8_t channel_uses_spx[AC3_MAX_CHANNELS]
channel uses spectral extension (chinspx)
Definition: ac3dec.h:124
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1934
#define LEVEL_MINUS_4POINT5DB
Definition: ac3.h:59
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
Definition: avcodec.h:2482
static int b3_mantissas[8]
Definition: ac3dec.c:50
#define AC3_BLOCK_SIZE
Definition: ac3.h:35
#define powf(x, y)
Definition: libm.h:48
static float dynamic_range_tab[256]
dynamic range table.
Definition: ac3dec.c:64
uint8_t input_buffer[AC3_FRAME_BUFFER_SIZE+FF_INPUT_BUFFER_PADDING_SIZE]
temp buffer to prevent overread
Definition: ac3dec.h:218
static void do_rematrixing(AC3DecodeContext *s)
Stereo rematrixing.
Definition: ac3dec.c:573
int bit_rate
the average bitrate
Definition: avcodec.h:1204
int b4_mant
Definition: ac3dec.c:416
static int b5_mantissas[16]
Definition: ac3dec.c:52
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2476
float loro_surround_mix_level
Definition: ac3dec.h:96
int dither_flag_syntax
dither flag syntax enabled (dithflage)
Definition: ac3dec.h:101
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3dec.h:159
uint32_t bit_rate
Definition: ac3.h:120
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:242
ret
Definition: avfilter.c:961
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:186
FFTContext imdct_512
for 512 sample IMDCT
Definition: ac3dec.h:196
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
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length) av_pure
Calculate the CRC of a block.
Definition: crc.c:320
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
#define FFMIN(a, b)
Definition: avcodec.h:925
static int b2_mantissas[128][3]
Definition: ac3dec.c:49
float drc_scale
percentage of dynamic range compression to be applied
Definition: ac3dec.h:154
int32_t fixed_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
fixed-point transform coefficients
Definition: ac3dec.h:212
Definition: ac3.h:69
AVCodecContext * avctx
parent context
Definition: ac3dec.h:71
static int b4_mantissas[128][2]
Definition: ac3dec.c:51
int channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3dec.h:111
int fbw_channels
number of full-bandwidth channels
Definition: ac3dec.h:143
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
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
uint8_t bap[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
bit allocation pointers
Definition: ac3dec.h:178
#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
void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
#define FFMAX(a, b)
Definition: avcodec.h:923
int sample_rate
samples per second
Definition: avcodec.h:1873
main external API structure.
Definition: avcodec.h:1146
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:538
#define LEVEL_ZERO
Definition: ac3.h:62
#define LEVEL_ONE
Definition: ac3.h:63
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:941
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3dec.h:114
int num_spx_bands
number of spx bands (nspxbnds)
Definition: ac3dec.h:130
#define OFFSET(x)
Definition: ac3dec.c:1433
void * buf
Definition: avisynth_c.h:594
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:97
static const float gain_levels[9]
Adjustments in dB gain.
Definition: ac3dec.c:67
float tmp_output[AC3_BLOCK_SIZE]
temporary storage for output before windowing
Definition: ac3dec.h:216
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
int b1
Definition: ac3dec.c:417
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:50
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
int bitstream_mode
bitstream mode (bsmod)
Definition: ac3dec.h:82
void av_frame_set_decode_error_flags(AVFrame *frame, int val)
uint8_t * data
Definition: avcodec.h:1063
static void set_downmix_coeffs(AC3DecodeContext *s)
Set stereo downmixing coefficients based on frame header info.
Definition: ac3dec.c:301
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:405
int frame_type
frame type (strmtyp)
Definition: ac3dec.h:76
uint16_t frame_size
Definition: ac3.h:122
static const uint8_t quantization_tab[16]
Quantization table: levels for symmetric.
Definition: ac3dec.c:58
int eac3
indicates if current frame is E-AC-3
Definition: ac3dec.h:89
int channel_uses_aht[AC3_MAX_CHANNELS]
channel AHT in use (chahtinu)
Definition: ac3dec.h:138
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:185
void * priv_data
Definition: avcodec.h:1182
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:201
av_cold void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
Initialize a float DSP context.
Definition: float_dsp.c:118
int cpl_in_use[AC3_MAX_BLOCKS]
coupling in use (cplinu)
Definition: ac3dec.h:109
int dba_mode[AC3_MAX_CHANNELS]
delta bit allocation mode
Definition: ac3dec.h:182
int first_cpl_leak
first coupling leak state (firstcplleak)
Definition: ac3dec.h:175
int surround_mix_level
Surround mix level index.
Definition: ac3dec.h:88
int snr_offset[AC3_MAX_CHANNELS]
signal-to-noise ratio offsets (snroffst)
Definition: ac3dec.h:176
int downmixed
indicates if coeffs are currently downmixed
Definition: ac3dec.h:147
float window[AC3_BLOCK_SIZE]
window coefficients
Definition: ac3dec.h:215
common internal api header.
#define ff_mdct_end
Definition: fft.h:161
int surround_mix_level
Surround mix level index.
Definition: ac3.h:110
int num_blocks
number of audio blocks
Definition: ac3dec.h:81
#define AC3_OUTPUT_LFEON
Definition: ac3dec.h:62
FmtConvertContext fmt_conv
optimized conversion functions
Definition: ac3dec.h:204
int b1_mant[2]
Definition: ac3dec.c:414
float transform_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
transform coefficients
Definition: ac3dec.h:213
int center_mix_level
Center mix level index.
Definition: ac3.h:109
static av_cold void ac3_tables_init(void)
Definition: ac3dec.c:108
int pre_mantissa[AC3_MAX_CHANNELS][AC3_MAX_COEFS][AC3_MAX_BLOCKS]
pre-IDCT mantissas
Definition: ac3dec.h:139
float spx_noise_blend[AC3_MAX_CHANNELS][SPX_MAX_BANDS]
spx noise blending factor (nblendfact)
Definition: ac3dec.h:133
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:164
uint8_t spx_band_sizes[SPX_MAX_BANDS]
number of bins in each spx band
Definition: ac3dec.h:131
#define AVERROR_INVALIDDATA
static int parse_frame_header(AC3DecodeContext *s)
Common function to parse AC-3 or E-AC-3 frame header.
Definition: ac3dec.c:241
#define LEVEL_PLUS_3DB
Definition: ac3.h:55
int snr_offset_strategy
SNR offset strategy (snroffststr)
Definition: ac3dec.h:99
int b2_mant[2]
Definition: ac3dec.c:415
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:158
int substreamid
substream identification
Definition: ac3.h:108
int channels
number of audio channels
Definition: avcodec.h:1874
int sample_rate
sample frequency, in Hz
Definition: ac3dec.h:80
int center_mix_level
Center mix level index.
Definition: ac3dec.h:87
uint8_t channels
Definition: ac3.h:121
int output_mode
output channel configuration
Definition: ac3dec.h:148
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:385
#define AVERROR(e)
float, planar
Definition: samplefmt.h:60
#define LEVEL_MINUS_6DB
Definition: ac3.h:60
void(* downmix)(float **samples, float(*matrix)[2], int out_ch, int in_ch, int len)
Definition: ac3dsp.h:135
int frame_size
current frame size, in bytes
Definition: ac3dec.h:78
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:700
int channel_layout
channel layout
Definition: ac3dec.h:84
static int symmetric_dequant(int code, int levels)
Symmetrical Dequantization reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantizati...
Definition: ac3dec.c:100
#define AV_EF_CRCCHECK
verify embedded CRCs
Definition: avcodec.h:2477
static void ac3_upmix_delay(AC3DecodeContext *s)
Upmix delay samples from stereo to original channel layout.
Definition: ac3dec.c:625
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
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
const uint8_t ff_ac3_dec_channel_map[8][2][6]
Table to remap channels from AC-3 order to SMPTE order.
Definition: ac3tab.c:120
int num_blocks
number of audio blocks
Definition: ac3.h:112
uint8_t channel_mode
Definition: ac3.h:105
AVLFG dith_state
for dither generation
Definition: ac3dec.h:191
int cpl_strategy_exists[AC3_MAX_BLOCKS]
coupling strategy exists (cplstre)
Definition: ac3dec.h:110
static av_cold int ac3_decode_init(AVCodecContext *avctx)
AVCodec initialization.
Definition: ac3dec.c:160
#define MULH(X, Y)
Definition: mathops.h:27
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:290
static void remove_dithering(AC3DecodeContext *s)
Remove random dithering from coupling range coefficients with zero-bit mantissas for coupled channels...
Definition: ac3dec.c:504
This structure stores compressed data.
Definition: avcodec.h:1040
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:150
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
#define EXP_D45
Definition: ac3.h:52
int channel_mode
channel mode (acmod)
Definition: ac3dec.h:83
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:128
int skip_syntax
skip field syntax enabled (skipflde)
Definition: ac3dec.h:105
int b2
Definition: ac3dec.c:418
int8_t dexps[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
decoded exponents
Definition: ac3dec.h:169