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 
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 
45 static uint8_t ungroup_3_in_7_bits_tab[128][3];
46 
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 
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 
64 static float dynamic_range_tab[256];
65 
67 static const float gain_levels[9] = {
70  LEVEL_ONE,
75  LEVEL_ZERO,
77 };
78 
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 
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 
161 {
162  AC3DecodeContext *s = avctx->priv_data;
163  s->avctx = avctx;
164 
165 #if FF_API_DRC_SCALE
166  if (avctx->drc_scale)
167  s->drc_scale = avctx->drc_scale;
168 #endif
169 
171  ac3_tables_init();
172  ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
173  ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
174  ff_kbd_window_init(s->window, 5.0, 256);
175  dsputil_init(&s->dsp, avctx);
177  ff_fmt_convert_init(&s->fmt_conv, avctx);
178  av_lfg_init(&s->dith_state, 0);
179 
180  /* set scale value for float to int16 conversion */
181  if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
182  s->mul_bias = 1.0f;
183  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
184  } else {
185  s->mul_bias = 32767.0f;
186  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
187  }
188 
189  /* allow downmixing to stereo or mono */
190  if (avctx->channels > 0 && avctx->request_channels > 0 &&
191  avctx->request_channels < avctx->channels &&
192  avctx->request_channels <= 2) {
193  avctx->channels = avctx->request_channels;
194  }
195  s->downmixed = 1;
196 
198  avctx->coded_frame = &s->frame;
199 
200  return 0;
201 }
202 
209 {
210  GetBitContext *gbc = &s->gbc;
211  int i;
212 
213  /* read the rest of the bsi. read twice for dual mono mode. */
214  i = !s->channel_mode;
215  do {
216  skip_bits(gbc, 5); // skip dialog normalization
217  if (get_bits1(gbc))
218  skip_bits(gbc, 8); //skip compression
219  if (get_bits1(gbc))
220  skip_bits(gbc, 8); //skip language code
221  if (get_bits1(gbc))
222  skip_bits(gbc, 7); //skip audio production information
223  } while (i--);
224 
225  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
226 
227  /* skip the timecodes (or extra bitstream information for Alternate Syntax)
228  TODO: read & use the xbsi1 downmix levels */
229  if (get_bits1(gbc))
230  skip_bits(gbc, 14); //skip timecode1 / xbsi1
231  if (get_bits1(gbc))
232  skip_bits(gbc, 14); //skip timecode2 / xbsi2
233 
234  /* skip additional bitstream info */
235  if (get_bits1(gbc)) {
236  i = get_bits(gbc, 6);
237  do {
238  skip_bits(gbc, 8);
239  } while (i--);
240  }
241 
242  return 0;
243 }
244 
249 {
250  AC3HeaderInfo hdr;
251  int err;
252 
253  err = avpriv_ac3_parse_header(&s->gbc, &hdr);
254  if (err)
255  return err;
256 
257  /* get decoding parameters from header info */
260  s->channel_mode = hdr.channel_mode;
262  s->lfe_on = hdr.lfe_on;
264  s->sample_rate = hdr.sample_rate;
265  s->bit_rate = hdr.bit_rate;
266  s->channels = hdr.channels;
267  s->fbw_channels = s->channels - s->lfe_on;
268  s->lfe_ch = s->fbw_channels + 1;
269  s->frame_size = hdr.frame_size;
272  s->num_blocks = hdr.num_blocks;
273  s->frame_type = hdr.frame_type;
274  s->substreamid = hdr.substreamid;
275 
276  if (s->lfe_on) {
277  s->start_freq[s->lfe_ch] = 0;
278  s->end_freq[s->lfe_ch] = 7;
279  s->num_exp_groups[s->lfe_ch] = 2;
280  s->channel_in_cpl[s->lfe_ch] = 0;
281  }
282 
283  if (hdr.bitstream_id <= 10) {
284  s->eac3 = 0;
285  s->snr_offset_strategy = 2;
286  s->block_switch_syntax = 1;
287  s->dither_flag_syntax = 1;
288  s->bit_allocation_syntax = 1;
289  s->fast_gain_syntax = 0;
290  s->first_cpl_leak = 0;
291  s->dba_syntax = 1;
292  s->skip_syntax = 1;
293  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
294  return ac3_parse_header(s);
295  } else if (CONFIG_EAC3_DECODER) {
296  s->eac3 = 1;
297  return ff_eac3_parse_header(s);
298  } else {
299  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
300  return AVERROR(ENOSYS);
301  }
302 }
303 
309 {
310  int i;
311  float cmix = gain_levels[s-> center_mix_level];
312  float smix = gain_levels[s->surround_mix_level];
313  float norm0, norm1;
314 
315  for (i = 0; i < s->fbw_channels; i++) {
317  s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
318  }
319  if (s->channel_mode > 1 && s->channel_mode & 1) {
320  s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
321  }
323  int nf = s->channel_mode - 2;
324  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
325  }
327  int nf = s->channel_mode - 4;
328  s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
329  }
330 
331  /* renormalize */
332  norm0 = norm1 = 0.0;
333  for (i = 0; i < s->fbw_channels; i++) {
334  norm0 += s->downmix_coeffs[i][0];
335  norm1 += s->downmix_coeffs[i][1];
336  }
337  norm0 = 1.0f / norm0;
338  norm1 = 1.0f / norm1;
339  for (i = 0; i < s->fbw_channels; i++) {
340  s->downmix_coeffs[i][0] *= norm0;
341  s->downmix_coeffs[i][1] *= norm1;
342  }
343 
344  if (s->output_mode == AC3_CHMODE_MONO) {
345  for (i = 0; i < s->fbw_channels; i++)
346  s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
347  s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
348  }
349 }
350 
355 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
356  uint8_t absexp, int8_t *dexps)
357 {
358  int i, j, grp, group_size;
359  int dexp[256];
360  int expacc, prevexp;
361 
362  /* unpack groups */
363  group_size = exp_strategy + (exp_strategy == EXP_D45);
364  for (grp = 0, i = 0; grp < ngrps; grp++) {
365  expacc = get_bits(gbc, 7);
366  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
367  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
368  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
369  }
370 
371  /* convert to absolute exps and expand groups */
372  prevexp = absexp;
373  for (i = 0, j = 0; i < ngrps * 3; i++) {
374  prevexp += dexp[i] - 2;
375  if (prevexp > 24U)
376  return -1;
377  switch (group_size) {
378  case 4: dexps[j++] = prevexp;
379  dexps[j++] = prevexp;
380  case 2: dexps[j++] = prevexp;
381  case 1: dexps[j++] = prevexp;
382  }
383  }
384  return 0;
385 }
386 
393 {
394  int bin, band, ch;
395 
396  bin = s->start_freq[CPL_CH];
397  for (band = 0; band < s->num_cpl_bands; band++) {
398  int band_start = bin;
399  int band_end = bin + s->cpl_band_sizes[band];
400  for (ch = 1; ch <= s->fbw_channels; ch++) {
401  if (s->channel_in_cpl[ch]) {
402  int cpl_coord = s->cpl_coords[ch][band] << 5;
403  for (bin = band_start; bin < band_end; bin++) {
404  s->fixed_coeffs[ch][bin] =
405  MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
406  }
407  if (ch == 2 && s->phase_flags[band]) {
408  for (bin = band_start; bin < band_end; bin++)
409  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
410  }
411  }
412  }
413  bin = band_end;
414  }
415 }
416 
420 typedef struct {
421  int b1_mant[2];
422  int b2_mant[2];
423  int b4_mant;
424  int b1;
425  int b2;
426  int b4;
427 } mant_groups;
428 
434 {
435  int start_freq = s->start_freq[ch_index];
436  int end_freq = s->end_freq[ch_index];
437  uint8_t *baps = s->bap[ch_index];
438  int8_t *exps = s->dexps[ch_index];
439  int *coeffs = s->fixed_coeffs[ch_index];
440  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
441  GetBitContext *gbc = &s->gbc;
442  int freq;
443 
444  for (freq = start_freq; freq < end_freq; freq++) {
445  int bap = baps[freq];
446  int mantissa;
447  switch (bap) {
448  case 0:
449  if (dither)
450  mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
451  else
452  mantissa = 0;
453  break;
454  case 1:
455  if (m->b1) {
456  m->b1--;
457  mantissa = m->b1_mant[m->b1];
458  } else {
459  int bits = get_bits(gbc, 5);
460  mantissa = b1_mantissas[bits][0];
461  m->b1_mant[1] = b1_mantissas[bits][1];
462  m->b1_mant[0] = b1_mantissas[bits][2];
463  m->b1 = 2;
464  }
465  break;
466  case 2:
467  if (m->b2) {
468  m->b2--;
469  mantissa = m->b2_mant[m->b2];
470  } else {
471  int bits = get_bits(gbc, 7);
472  mantissa = b2_mantissas[bits][0];
473  m->b2_mant[1] = b2_mantissas[bits][1];
474  m->b2_mant[0] = b2_mantissas[bits][2];
475  m->b2 = 2;
476  }
477  break;
478  case 3:
479  mantissa = b3_mantissas[get_bits(gbc, 3)];
480  break;
481  case 4:
482  if (m->b4) {
483  m->b4 = 0;
484  mantissa = m->b4_mant;
485  } else {
486  int bits = get_bits(gbc, 7);
487  mantissa = b4_mantissas[bits][0];
488  m->b4_mant = b4_mantissas[bits][1];
489  m->b4 = 1;
490  }
491  break;
492  case 5:
493  mantissa = b5_mantissas[get_bits(gbc, 4)];
494  break;
495  default: /* 6 to 15 */
496  /* Shift mantissa and sign-extend it. */
497  mantissa = get_sbits(gbc, quantization_tab[bap]);
498  mantissa <<= 24 - quantization_tab[bap];
499  break;
500  }
501  coeffs[freq] = mantissa >> exps[freq];
502  }
503 }
504 
511  int ch, i;
512 
513  for (ch = 1; ch <= s->fbw_channels; ch++) {
514  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
515  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
516  if (!s->bap[CPL_CH][i])
517  s->fixed_coeffs[ch][i] = 0;
518  }
519  }
520  }
521 }
522 
523 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
524  mant_groups *m)
525 {
526  if (!s->channel_uses_aht[ch]) {
528  } else {
529  /* if AHT is used, mantissas for all blocks are encoded in the first
530  block of the frame. */
531  int bin;
532  if (!blk && CONFIG_EAC3_DECODER)
534  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
535  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
536  }
537  }
538 }
539 
544 {
545  int ch, end;
546  int got_cplchan = 0;
547  mant_groups m;
548 
549  m.b1 = m.b2 = m.b4 = 0;
550 
551  for (ch = 1; ch <= s->channels; ch++) {
552  /* transform coefficients for full-bandwidth channel */
553  decode_transform_coeffs_ch(s, blk, ch, &m);
554  /* tranform coefficients for coupling channel come right after the
555  coefficients for the first coupled channel*/
556  if (s->channel_in_cpl[ch]) {
557  if (!got_cplchan) {
558  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
560  got_cplchan = 1;
561  }
562  end = s->end_freq[CPL_CH];
563  } else {
564  end = s->end_freq[ch];
565  }
566  do
567  s->fixed_coeffs[ch][end] = 0;
568  while (++end < 256);
569  }
570 
571  /* zero the dithered coefficients for appropriate channels */
572  remove_dithering(s);
573 }
574 
580 {
581  int bnd, i;
582  int end, bndend;
583 
584  end = FFMIN(s->end_freq[1], s->end_freq[2]);
585 
586  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
587  if (s->rematrixing_flags[bnd]) {
588  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
589  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
590  int tmp0 = s->fixed_coeffs[1][i];
591  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
592  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
593  }
594  }
595  }
596 }
597 
603 static inline void do_imdct(AC3DecodeContext *s, int channels)
604 {
605  int ch;
606 
607  for (ch = 1; ch <= channels; ch++) {
608  if (s->block_switch[ch]) {
609  int i;
610  float *x = s->tmp_output + 128;
611  for (i = 0; i < 128; i++)
612  x[i] = s->transform_coeffs[ch][2 * i];
613  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
614  s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
615  s->tmp_output, s->window, 128);
616  for (i = 0; i < 128; i++)
617  x[i] = s->transform_coeffs[ch][2 * i + 1];
618  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
619  } else {
621  s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
622  s->tmp_output, s->window, 128);
623  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
624  }
625  }
626 }
627 
631 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2],
632  int out_ch, int in_ch, int len)
633 {
634  int i, j;
635  float v0, v1;
636  if (out_ch == 2) {
637  for (i = 0; i < len; i++) {
638  v0 = v1 = 0.0f;
639  for (j = 0; j < in_ch; j++) {
640  v0 += samples[j][i] * matrix[j][0];
641  v1 += samples[j][i] * matrix[j][1];
642  }
643  samples[0][i] = v0;
644  samples[1][i] = v1;
645  }
646  } else if (out_ch == 1) {
647  for (i = 0; i < len; i++) {
648  v0 = 0.0f;
649  for (j = 0; j < in_ch; j++)
650  v0 += samples[j][i] * matrix[j][0];
651  samples[0][i] = v0;
652  }
653  }
654 }
655 
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 
753 {
754  int fbw_channels = s->fbw_channels;
755  int channel_mode = s->channel_mode;
756  int i, bnd, seg, ch;
757  int different_transforms;
758  int downmix_output;
759  int cpl_in_use;
760  GetBitContext *gbc = &s->gbc;
761  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
762 
763  memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
764 
765  /* block switch flags */
766  different_transforms = 0;
767  if (s->block_switch_syntax) {
768  for (ch = 1; ch <= fbw_channels; ch++) {
769  s->block_switch[ch] = get_bits1(gbc);
770  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
771  different_transforms = 1;
772  }
773  }
774 
775  /* dithering flags */
776  if (s->dither_flag_syntax) {
777  for (ch = 1; ch <= fbw_channels; ch++) {
778  s->dither_flag[ch] = get_bits1(gbc);
779  }
780  }
781 
782  /* dynamic range */
783  i = !s->channel_mode;
784  do {
785  if (get_bits1(gbc)) {
786  s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
787  s->drc_scale) + 1.0;
788  } else if (blk == 0) {
789  s->dynamic_range[i] = 1.0f;
790  }
791  } while (i--);
792 
793  /* spectral extension strategy */
794  if (s->eac3 && (!blk || get_bits1(gbc))) {
795  s->spx_in_use = get_bits1(gbc);
796  if (s->spx_in_use) {
797  int dst_start_freq, dst_end_freq, src_start_freq,
798  start_subband, end_subband;
799 
800  /* determine which channels use spx */
801  if (s->channel_mode == AC3_CHMODE_MONO) {
802  s->channel_uses_spx[1] = 1;
803  } else {
804  for (ch = 1; ch <= fbw_channels; ch++)
805  s->channel_uses_spx[ch] = get_bits1(gbc);
806  }
807 
808  /* get the frequency bins of the spx copy region and the spx start
809  and end subbands */
810  dst_start_freq = get_bits(gbc, 2);
811  start_subband = get_bits(gbc, 3) + 2;
812  if (start_subband > 7)
813  start_subband += start_subband - 7;
814  end_subband = get_bits(gbc, 3) + 5;
815  if (end_subband > 7)
816  end_subband += end_subband - 7;
817  dst_start_freq = dst_start_freq * 12 + 25;
818  src_start_freq = start_subband * 12 + 25;
819  dst_end_freq = end_subband * 12 + 25;
820 
821  /* check validity of spx ranges */
822  if (start_subband >= end_subband) {
823  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
824  "range (%d >= %d)\n", start_subband, end_subband);
825  return AVERROR_INVALIDDATA;
826  }
827  if (dst_start_freq >= src_start_freq) {
828  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
829  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
830  return AVERROR_INVALIDDATA;
831  }
832 
833  s->spx_dst_start_freq = dst_start_freq;
834  s->spx_src_start_freq = src_start_freq;
835  s->spx_dst_end_freq = dst_end_freq;
836 
837  decode_band_structure(gbc, blk, s->eac3, 0,
838  start_subband, end_subband,
840  &s->num_spx_bands,
841  s->spx_band_sizes);
842  } else {
843  for (ch = 1; ch <= fbw_channels; ch++) {
844  s->channel_uses_spx[ch] = 0;
845  s->first_spx_coords[ch] = 1;
846  }
847  }
848  }
849 
850  /* spectral extension coordinates */
851  if (s->spx_in_use) {
852  for (ch = 1; ch <= fbw_channels; ch++) {
853  if (s->channel_uses_spx[ch]) {
854  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
855  float spx_blend;
856  int bin, master_spx_coord;
857 
858  s->first_spx_coords[ch] = 0;
859  spx_blend = get_bits(gbc, 5) * (1.0f/32);
860  master_spx_coord = get_bits(gbc, 2) * 3;
861 
862  bin = s->spx_src_start_freq;
863  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
864  int bandsize;
865  int spx_coord_exp, spx_coord_mant;
866  float nratio, sblend, nblend, spx_coord;
867 
868  /* calculate blending factors */
869  bandsize = s->spx_band_sizes[bnd];
870  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
871  nratio = av_clipf(nratio, 0.0f, 1.0f);
872  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
873  // to give unity variance
874  sblend = sqrtf(1.0f - nratio);
875  bin += bandsize;
876 
877  /* decode spx coordinates */
878  spx_coord_exp = get_bits(gbc, 4);
879  spx_coord_mant = get_bits(gbc, 2);
880  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
881  else spx_coord_mant += 4;
882  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
883  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
884 
885  /* multiply noise and signal blending factors by spx coordinate */
886  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
887  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
888  }
889  }
890  } else {
891  s->first_spx_coords[ch] = 1;
892  }
893  }
894  }
895 
896  /* coupling strategy */
897  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
898  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
899  if (!s->eac3)
900  s->cpl_in_use[blk] = get_bits1(gbc);
901  if (s->cpl_in_use[blk]) {
902  /* coupling in use */
903  int cpl_start_subband, cpl_end_subband;
904 
905  if (channel_mode < AC3_CHMODE_STEREO) {
906  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
907  return AVERROR_INVALIDDATA;
908  }
909 
910  /* check for enhanced coupling */
911  if (s->eac3 && get_bits1(gbc)) {
912  /* TODO: parse enhanced coupling strategy info */
913  av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
914  return -1;
915  }
916 
917  /* determine which channels are coupled */
918  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
919  s->channel_in_cpl[1] = 1;
920  s->channel_in_cpl[2] = 1;
921  } else {
922  for (ch = 1; ch <= fbw_channels; ch++)
923  s->channel_in_cpl[ch] = get_bits1(gbc);
924  }
925 
926  /* phase flags in use */
927  if (channel_mode == AC3_CHMODE_STEREO)
928  s->phase_flags_in_use = get_bits1(gbc);
929 
930  /* coupling frequency range */
931  cpl_start_subband = get_bits(gbc, 4);
932  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
933  get_bits(gbc, 4) + 3;
934  if (cpl_start_subband >= cpl_end_subband) {
935  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
936  cpl_start_subband, cpl_end_subband);
937  return AVERROR_INVALIDDATA;
938  }
939  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
940  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
941 
942  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
943  cpl_end_subband,
945  &s->num_cpl_bands, s->cpl_band_sizes);
946  } else {
947  /* coupling not in use */
948  for (ch = 1; ch <= fbw_channels; ch++) {
949  s->channel_in_cpl[ch] = 0;
950  s->first_cpl_coords[ch] = 1;
951  }
952  s->first_cpl_leak = s->eac3;
953  s->phase_flags_in_use = 0;
954  }
955  } else if (!s->eac3) {
956  if (!blk) {
957  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
958  "be present in block 0\n");
959  return AVERROR_INVALIDDATA;
960  } else {
961  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
962  }
963  }
964  cpl_in_use = s->cpl_in_use[blk];
965 
966  /* coupling coordinates */
967  if (cpl_in_use) {
968  int cpl_coords_exist = 0;
969 
970  for (ch = 1; ch <= fbw_channels; ch++) {
971  if (s->channel_in_cpl[ch]) {
972  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
973  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
974  s->first_cpl_coords[ch] = 0;
975  cpl_coords_exist = 1;
976  master_cpl_coord = 3 * get_bits(gbc, 2);
977  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
978  cpl_coord_exp = get_bits(gbc, 4);
979  cpl_coord_mant = get_bits(gbc, 4);
980  if (cpl_coord_exp == 15)
981  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
982  else
983  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
984  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
985  }
986  } else if (!blk) {
987  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
988  "be present in block 0\n");
989  return AVERROR_INVALIDDATA;
990  }
991  } else {
992  /* channel not in coupling */
993  s->first_cpl_coords[ch] = 1;
994  }
995  }
996  /* phase flags */
997  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
998  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
999  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1000  }
1001  }
1002  }
1003 
1004  /* stereo rematrixing strategy and band structure */
1005  if (channel_mode == AC3_CHMODE_STEREO) {
1006  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1007  s->num_rematrixing_bands = 4;
1008  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1009  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1010  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1011  s->num_rematrixing_bands--;
1012  }
1013  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1014  s->rematrixing_flags[bnd] = get_bits1(gbc);
1015  } else if (!blk) {
1016  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1017  "new rematrixing strategy not present in block 0\n");
1018  s->num_rematrixing_bands = 0;
1019  }
1020  }
1021 
1022  /* exponent strategies for each channel */
1023  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1024  if (!s->eac3)
1025  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1026  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1027  bit_alloc_stages[ch] = 3;
1028  }
1029 
1030  /* channel bandwidth */
1031  for (ch = 1; ch <= fbw_channels; ch++) {
1032  s->start_freq[ch] = 0;
1033  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1034  int group_size;
1035  int prev = s->end_freq[ch];
1036  if (s->channel_in_cpl[ch])
1037  s->end_freq[ch] = s->start_freq[CPL_CH];
1038  else if (s->channel_uses_spx[ch])
1039  s->end_freq[ch] = s->spx_src_start_freq;
1040  else {
1041  int bandwidth_code = get_bits(gbc, 6);
1042  if (bandwidth_code > 60) {
1043  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1044  return AVERROR_INVALIDDATA;
1045  }
1046  s->end_freq[ch] = bandwidth_code * 3 + 73;
1047  }
1048  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1049  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1050  if (blk > 0 && s->end_freq[ch] != prev)
1051  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1052  }
1053  }
1054  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1056  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1057  }
1058 
1059  /* decode exponents for each channel */
1060  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1061  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1062  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1063  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1064  s->num_exp_groups[ch], s->dexps[ch][0],
1065  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1066  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1067  return AVERROR_INVALIDDATA;
1068  }
1069  if (ch != CPL_CH && ch != s->lfe_ch)
1070  skip_bits(gbc, 2); /* skip gainrng */
1071  }
1072  }
1073 
1074  /* bit allocation information */
1075  if (s->bit_allocation_syntax) {
1076  if (get_bits1(gbc)) {
1082  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1083  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1084  } else if (!blk) {
1085  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1086  "be present in block 0\n");
1087  return AVERROR_INVALIDDATA;
1088  }
1089  }
1090 
1091  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1092  if (!s->eac3 || !blk) {
1093  if (s->snr_offset_strategy && get_bits1(gbc)) {
1094  int snr = 0;
1095  int csnr;
1096  csnr = (get_bits(gbc, 6) - 15) << 4;
1097  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1098  /* snr offset */
1099  if (ch == i || s->snr_offset_strategy == 2)
1100  snr = (csnr + get_bits(gbc, 4)) << 2;
1101  /* run at least last bit allocation stage if snr offset changes */
1102  if (blk && s->snr_offset[ch] != snr) {
1103  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1104  }
1105  s->snr_offset[ch] = snr;
1106 
1107  /* fast gain (normal AC-3 only) */
1108  if (!s->eac3) {
1109  int prev = s->fast_gain[ch];
1110  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1111  /* run last 2 bit allocation stages if fast gain changes */
1112  if (blk && prev != s->fast_gain[ch])
1113  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1114  }
1115  }
1116  } else if (!s->eac3 && !blk) {
1117  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1118  return AVERROR_INVALIDDATA;
1119  }
1120  }
1121 
1122  /* fast gain (E-AC-3 only) */
1123  if (s->fast_gain_syntax && get_bits1(gbc)) {
1124  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1125  int prev = s->fast_gain[ch];
1126  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1127  /* run last 2 bit allocation stages if fast gain changes */
1128  if (blk && prev != s->fast_gain[ch])
1129  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1130  }
1131  } else if (s->eac3 && !blk) {
1132  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1133  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1134  }
1135 
1136  /* E-AC-3 to AC-3 converter SNR offset */
1137  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1138  skip_bits(gbc, 10); // skip converter snr offset
1139  }
1140 
1141  /* coupling leak information */
1142  if (cpl_in_use) {
1143  if (s->first_cpl_leak || get_bits1(gbc)) {
1144  int fl = get_bits(gbc, 3);
1145  int sl = get_bits(gbc, 3);
1146  /* run last 2 bit allocation stages for coupling channel if
1147  coupling leak changes */
1148  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1149  sl != s->bit_alloc_params.cpl_slow_leak)) {
1150  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1151  }
1154  } else if (!s->eac3 && !blk) {
1155  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1156  "be present in block 0\n");
1157  return AVERROR_INVALIDDATA;
1158  }
1159  s->first_cpl_leak = 0;
1160  }
1161 
1162  /* delta bit allocation information */
1163  if (s->dba_syntax && get_bits1(gbc)) {
1164  /* delta bit allocation exists (strategy) */
1165  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1166  s->dba_mode[ch] = get_bits(gbc, 2);
1167  if (s->dba_mode[ch] == DBA_RESERVED) {
1168  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1169  return AVERROR_INVALIDDATA;
1170  }
1171  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1172  }
1173  /* channel delta offset, len and bit allocation */
1174  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1175  if (s->dba_mode[ch] == DBA_NEW) {
1176  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1177  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1178  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1179  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1180  s->dba_values[ch][seg] = get_bits(gbc, 3);
1181  }
1182  /* run last 2 bit allocation stages if new dba values */
1183  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1184  }
1185  }
1186  } else if (blk == 0) {
1187  for (ch = 0; ch <= s->channels; ch++) {
1188  s->dba_mode[ch] = DBA_NONE;
1189  }
1190  }
1191 
1192  /* Bit allocation */
1193  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1194  if (bit_alloc_stages[ch] > 2) {
1195  /* Exponent mapping into PSD and PSD integration */
1197  s->start_freq[ch], s->end_freq[ch],
1198  s->psd[ch], s->band_psd[ch]);
1199  }
1200  if (bit_alloc_stages[ch] > 1) {
1201  /* Compute excitation function, Compute masking curve, and
1202  Apply delta bit allocation */
1204  s->start_freq[ch], s->end_freq[ch],
1205  s->fast_gain[ch], (ch == s->lfe_ch),
1206  s->dba_mode[ch], s->dba_nsegs[ch],
1207  s->dba_offsets[ch], s->dba_lengths[ch],
1208  s->dba_values[ch], s->mask[ch])) {
1209  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1210  return AVERROR_INVALIDDATA;
1211  }
1212  }
1213  if (bit_alloc_stages[ch] > 0) {
1214  /* Compute bit allocation */
1215  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1217  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1218  s->start_freq[ch], s->end_freq[ch],
1219  s->snr_offset[ch],
1221  bap_tab, s->bap[ch]);
1222  }
1223  }
1224 
1225  /* unused dummy data */
1226  if (s->skip_syntax && get_bits1(gbc)) {
1227  int skipl = get_bits(gbc, 9);
1228  while (skipl--)
1229  skip_bits(gbc, 8);
1230  }
1231 
1232  /* unpack the transform coefficients
1233  this also uncouples channels if coupling is in use. */
1234  decode_transform_coeffs(s, blk);
1235 
1236  /* TODO: generate enhanced coupling coordinates and uncouple */
1237 
1238  /* recover coefficients if rematrixing is in use */
1239  if (s->channel_mode == AC3_CHMODE_STEREO)
1240  do_rematrixing(s);
1241 
1242  /* apply scaling to coefficients (headroom, dynrng) */
1243  for (ch = 1; ch <= s->channels; ch++) {
1244  float gain = s->mul_bias / 4194304.0f;
1245  if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1246  gain *= s->dynamic_range[2 - ch];
1247  } else {
1248  gain *= s->dynamic_range[0];
1249  }
1251  s->fixed_coeffs[ch], gain, 256);
1252  }
1253 
1254  /* apply spectral extension to high frequency bins */
1255  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1257  }
1258 
1259  /* downmix and MDCT. order depends on whether block switching is used for
1260  any channel in this block. this is because coefficients for the long
1261  and short transforms cannot be mixed. */
1262  downmix_output = s->channels != s->out_channels &&
1263  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1264  s->fbw_channels == s->out_channels);
1265  if (different_transforms) {
1266  /* the delay samples have already been downmixed, so we upmix the delay
1267  samples in order to reconstruct all channels before downmixing. */
1268  if (s->downmixed) {
1269  s->downmixed = 0;
1270  ac3_upmix_delay(s);
1271  }
1272 
1273  do_imdct(s, s->channels);
1274 
1275  if (downmix_output) {
1277  s->out_channels, s->fbw_channels, 256);
1278  }
1279  } else {
1280  if (downmix_output) {
1282  s->out_channels, s->fbw_channels, 256);
1283  }
1284 
1285  if (downmix_output && !s->downmixed) {
1286  s->downmixed = 1;
1288  s->fbw_channels, 128);
1289  }
1290 
1291  do_imdct(s, s->out_channels);
1292  }
1293 
1294  return 0;
1295 }
1296 
1300 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1301  int *got_frame_ptr, AVPacket *avpkt)
1302 {
1303  const uint8_t *buf = avpkt->data;
1304  int buf_size = avpkt->size;
1305  AC3DecodeContext *s = avctx->priv_data;
1306  float *out_samples_flt;
1307  int16_t *out_samples_s16;
1308  int blk, ch, err, ret;
1309  const uint8_t *channel_map;
1310  const float *output[AC3_MAX_CHANNELS];
1311 
1312  /* copy input buffer to decoder context to avoid reading past the end
1313  of the buffer, which can be caused by a damaged input stream. */
1314  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1315  // seems to be byte-swapped AC-3
1316  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1317  s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1318  } else
1319  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1320  buf = s->input_buffer;
1321  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1322  init_get_bits(&s->gbc, buf, buf_size * 8);
1323 
1324  /* parse the syncinfo */
1325  err = parse_frame_header(s);
1326 
1327  if (err) {
1328  switch (err) {
1330  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1331  return AVERROR_INVALIDDATA;
1333  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1334  break;
1336  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1337  break;
1339  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1340  break;
1342  /* skip frame if CRC is ok. otherwise use error concealment. */
1343  /* TODO: add support for substreams and dependent frames */
1345  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1346  "skipping frame\n");
1347  *got_frame_ptr = 0;
1348  return buf_size;
1349  } else {
1350  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1351  }
1352  break;
1355  break;
1356  default: // Normal AVERROR do not try to recover.
1357  *got_frame_ptr = 0;
1358  return err;
1359  }
1360  } else {
1361  /* check that reported frame size fits in input buffer */
1362  if (s->frame_size > buf_size) {
1363  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1365  } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1366  /* check for crc mismatch */
1367  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1368  s->frame_size - 2)) {
1369  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1371  }
1372  }
1373  }
1374 
1375  /* if frame is ok, set audio parameters */
1376  if (!err) {
1377  avctx->sample_rate = s->sample_rate;
1378  avctx->bit_rate = s->bit_rate;
1379  }
1380 
1381  /* channel config */
1382  if (!err || (s->channels && s->out_channels != s->channels)) {
1383  s->out_channels = s->channels;
1384  s->output_mode = s->channel_mode;
1385  if (s->lfe_on)
1387  if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1388  avctx->request_channels < s->channels) {
1389  s->out_channels = avctx->request_channels;
1390  s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1392  }
1393  avctx->channels = s->out_channels;
1394  avctx->channel_layout = s->channel_layout;
1395 
1396  /* set downmixing coefficients if needed */
1397  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1398  s->fbw_channels == s->out_channels)) {
1399  set_downmix_coeffs(s);
1400  }
1401  } else if (!s->channels) {
1402  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1403  return AVERROR_INVALIDDATA;
1404  }
1405  avctx->channels = s->out_channels;
1406 
1407  /* set audio service type based on bitstream mode for AC-3 */
1408  avctx->audio_service_type = s->bitstream_mode;
1409  if (s->bitstream_mode == 0x7 && s->channels > 1)
1411 
1412  /* get output buffer */
1413  s->frame.nb_samples = s->num_blocks * 256;
1414  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
1415  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1416  return ret;
1417  }
1418  out_samples_flt = (float *)s->frame.data[0];
1419  out_samples_s16 = (int16_t *)s->frame.data[0];
1420 
1421  /* decode the audio blocks */
1422  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1423  for (ch = 0; ch < s->out_channels; ch++)
1424  output[ch] = s->output[channel_map[ch]];
1425  for (blk = 0; blk < s->num_blocks; blk++) {
1426  if (!err && decode_audio_block(s, blk)) {
1427  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1428  err = 1;
1429  }
1430  if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1431  s->fmt_conv.float_interleave(out_samples_flt, output, 256,
1432  s->out_channels);
1433  out_samples_flt += 256 * s->out_channels;
1434  } else {
1435  s->fmt_conv.float_to_int16_interleave(out_samples_s16, output, 256,
1436  s->out_channels);
1437  out_samples_s16 += 256 * s->out_channels;
1438  }
1439  }
1440 
1441  *got_frame_ptr = 1;
1442  *(AVFrame *)data = s->frame;
1443 
1444  return FFMIN(buf_size, s->frame_size);
1445 }
1446 
1451 {
1452  AC3DecodeContext *s = avctx->priv_data;
1453  ff_mdct_end(&s->imdct_512);
1454  ff_mdct_end(&s->imdct_256);
1455 
1456  return 0;
1457 }
1458 
1459 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1460 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1461 static const AVOption options[] = {
1462  { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {1.0}, 0.0, 1.0, PAR },
1463  { NULL},
1464 };
1465 
1466 static const AVClass ac3_decoder_class = {
1467  .class_name = "AC3 decoder",
1468  .item_name = av_default_item_name,
1469  .option = options,
1470  .version = LIBAVUTIL_VERSION_INT,
1471 };
1472 
1474  .name = "ac3",
1475  .type = AVMEDIA_TYPE_AUDIO,
1476  .id = CODEC_ID_AC3,
1477  .priv_data_size = sizeof (AC3DecodeContext),
1478  .init = ac3_decode_init,
1479  .close = ac3_decode_end,
1481  .capabilities = CODEC_CAP_DR1,
1482  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1483  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1486  .priv_class = &ac3_decoder_class,
1487 };
1488 
1489 #if CONFIG_EAC3_DECODER
1490 static const AVClass eac3_decoder_class = {
1491  .class_name = "E-AC3 decoder",
1492  .item_name = av_default_item_name,
1493  .option = options,
1494  .version = LIBAVUTIL_VERSION_INT,
1495 };
1496 
1497 AVCodec ff_eac3_decoder = {
1498  .name = "eac3",
1499  .type = AVMEDIA_TYPE_AUDIO,
1500  .id = CODEC_ID_EAC3,
1501  .priv_data_size = sizeof (AC3DecodeContext),
1502  .init = ac3_decode_init,
1503  .close = ac3_decode_end,
1505  .capabilities = CODEC_CAP_DR1,
1506  .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1507  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1510  .priv_class = &eac3_decoder_class,
1511 };
1512 #endif
uint8_t bitstream_mode
Definition: ac3.h:102
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Definition: dsputil.h:417
AVCodec ff_ac3_decoder
Definition: ac3dec.c:1473
#define CONFIG_EAC3_DECODER
Definition: config.h:445
uint64_t channel_layout
Definition: ac3.h:121
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:177
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
AV_WL32 AV_WL24 AV_WL16 AV_WB32 AV_WB24 AV_RB16
Definition: bytestream.h:89
Audio Video Frame.
Definition: avcodec.h:985
static short * samples
Definition: ffmpeg.c:233
int16_t psd[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
scaled exponents
Definition: ac3dec.h:173
int spx_in_use
spectral extension in use (spxinu)
Definition: ac3dec.h:117
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:118
AVOption.
Definition: opt.h:244
uint8_t dba_offsets[AC3_MAX_CHANNELS][8]
delta segment offsets
Definition: ac3dec.h:178
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:184
int16_t mask[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
masking curve values
Definition: ac3dec.h:175
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
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
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2000
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:117
av_cold void ff_ac3_common_init(void)
Initialize some tables.
Definition: ac3.c:220
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:54
AVFrame frame
AVFrame for decoded output.
Definition: ac3dec.h:71
int size
Definition: avcodec.h:909
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:433
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:355
AVOptions.
int channels
number of total channels
Definition: ac3dec.h:138
int b4
Definition: ac3dec.c:426
int spx_dst_end_freq
spx end frequency bin
Definition: ac3dec.h:121
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, mant_groups *m)
Definition: ac3dec.c:523
#define EXP_REUSE
Definition: ac3.h:45
int exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS]
exponent strategies (expstr)
Definition: ac3dec.h:164
float dynamic_range[2]
dynamic range
Definition: ac3dec.h:147
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:128
int block_switch[AC3_MAX_CHANNELS]
block switch flags (blksw)
Definition: ac3dec.h:189
signed 16 bits
Definition: samplefmt.h:30
#define blk(i)
Definition: sha.c:163
int dba_syntax
delta bit allocation syntax enabled (dbaflde)
Definition: ac3dec.h:98
void(* float_interleave)(float *dst, const float **src, unsigned int len, int channels)
Convert multiple arrays of float to an array of interleaved float.
Definition: fmtconvert.h:83
AVCodec.
Definition: avcodec.h:3189
int spx_src_start_freq
spx start frequency bin
Definition: ac3dec.h:120
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:223
#define v(n)
Definition: regs.h:34
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3dec.h:109
#define AC3_FRAME_BUFFER_SIZE
Large enough for maximum possible frame size when the specification limit is ignored.
Definition: ac3dec.h:66
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:3141
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:38
float downmix_coeffs[AC3_MAX_CHANNELS][2]
stereo downmix coefficients
Definition: ac3dec.h:140
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
void(* float_to_int16_interleave)(int16_t *dst, const float **src, long len, int channels)
Convert multiple arrays of float to an interleaved array of int16_t.
Definition: fmtconvert.h:69
void(* int32_to_float_fmul_scalar)(float *dst, const int *src, float mul, int len)
Convert an array of int32_t to float and multiply by a float value.
Definition: fmtconvert.h:38
uint8_t bits
Definition: crc.c:31
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1464
#define av_cold
Definition: attributes.h:71
int first_cpl_coords[AC3_MAX_CHANNELS]
first coupling coordinates states (firstcplcos)
Definition: ac3dec.h:111
uint8_t lfe_on
Definition: ac3.h:104
void(* ac3_downmix)(float(*samples)[256], float(*matrix)[2], int out_ch, int in_ch, int len)
Definition: dsputil.h:410
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:97
static void do_imdct(AC3DecodeContext *s, int channels)
Inverse MDCT Transform.
Definition: ac3dec.c:603
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
Definition: ac3dec.c:1450
static uint8_t ungroup_3_in_7_bits_tab[128][3]
table for ungrouping 3 values in 7 bits.
Definition: ac3dec.c:45
static const AVOption options[]
Definition: ac3dec.c:1461
float output[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
output after imdct transform and windowing
Definition: ac3dec.h:207
int num_rematrixing_bands
number of rematrixing bands (nrematbnd)
Definition: ac3dec.h:157
int fast_gain[AC3_MAX_CHANNELS]
fast gain values/SMR's (fgain)
Definition: ac3dec.h:171
const char data[16]
Definition: mxf.c:60
uint8_t * data
Definition: avcodec.h:908
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:112
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:162
uint8_t sr_shift
Definition: ac3.h:116
uint8_t bitstream_id
Definition: ac3.h:101
#define LEVEL_MINUS_1POINT5DB
Definition: ac3.h:55
float delay[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]
delay - added to the next block
Definition: ac3dec.h:204
int bit_allocation_syntax
bit allocation model syntax enabled (bamode)
Definition: ac3dec.h:96
int phase_flags_in_use
phase flags in use (phsflginu)
Definition: ac3dec.h:106
av_cold void dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2789
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:336
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:420
int phase_flags[AC3_MAX_CPL_BANDS]
phase flags (phsflg)
Definition: ac3dec.h:107
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:719
int out_channels
number of output channels
Definition: ac3dec.h:143
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:87
int substreamid
substream identification
Definition: ac3dec.h:77
FFTContext imdct_256
for 256 sample IMDCT
Definition: ac3dec.h:191
DSPContext dsp
for optimization
Definition: ac3dec.h:195
static int decode_audio_block(AC3DecodeContext *s, int blk)
Decode a single audio block from the AC-3 bitstream.
Definition: ac3dec.c:752
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: dsputil.h:394
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:105
int lfe_ch
index of LFE channel
Definition: ac3dec.h:139
#define AVERROR(e)
Definition: error.h:43
uint8_t first_spx_coords[AC3_MAX_CHANNELS]
first spx coordinates states (firstspxcos)
Definition: ac3dec.h:126
AC3BitAllocParameters bit_alloc_params
bit allocation parameters
Definition: ac3dec.h:168
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
Decode the transform coefficients.
Definition: ac3dec.c:543
enum AVSampleFormat request_sample_fmt
Used to request a sample format from the decoder.
Definition: avcodec.h:3148
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:191
#define PAR
Definition: ac3dec.c:1460
uint8_t sr_code
Definition: ac3.h:100
AC3DSPContext ac3dsp
Definition: ac3dec.h:196
#define LEVEL_MINUS_9DB
Definition: ac3.h:59
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:31
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1355
int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, int start, int end, int fast_gain, int is_lfe, int dba_mode, int dba_nsegs, uint8_t *dba_offsets, uint8_t *dba_lengths, uint8_t *dba_values, int16_t *mask)
Calculate the masking curve.
Definition: ac3.c:123
Definition: ac3.h:66
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
const char * name
Name of the codec implementation.
Definition: avcodec.h:3196
Coded AC-3 header values up to the lfeon element, plus derived values.
Definition: ac3.h:94
#define ff_mdct_init
Definition: fft.h:146
uint16_t sample_rate
Definition: ac3.h:117
static const AVClass ac3_decoder_class
Definition: ac3dec.c:1466
#define FFMAX(a, b)
Definition: common.h:53
#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:1300
int block_switch_syntax
block switch syntax enabled (blkswe)
Definition: ac3dec.h:94
int fast_gain_syntax
fast gain codes enabled (frmfgaincode)
Definition: ac3dec.h:97
int16_t band_psd[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]
interpolated exponents
Definition: ac3dec.h:174
uint8_t channel_uses_spx[AC3_MAX_CHANNELS]
channel uses spectral extension (chinspx)
Definition: ac3dec.h:118
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2870
#define LEVEL_MINUS_4POINT5DB
Definition: ac3.h:57
static int b3_mantissas[8]
Definition: ac3dec.c:50
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:208
static void do_rematrixing(AC3DecodeContext *s)
Stereo rematrixing.
Definition: ac3dec.c:579
int bit_rate
the average bitrate
Definition: avcodec.h:1340
int b4_mant
Definition: ac3dec.c:423
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:3155
#define FFMIN(a, b)
Definition: common.h:55
#define f(n)
Definition: regs.h:33
int dither_flag_syntax
dither flag syntax enabled (dithflage)
Definition: ac3dec.h:95
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3dec.h:153
uint32_t bit_rate
Definition: ac3.h:118
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:174
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:180
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Definition: utils.c:1867
FFTContext imdct_512
for 512 sample IMDCT
Definition: ac3dec.h:190
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
static int b2_mantissas[128][3]
Definition: ac3dec.c:49
float drc_scale
percentage of dynamic range compression to be applied
Definition: ac3dec.h:148
Definition: ac3.h:67
AVCodecContext * avctx
parent context
Definition: ac3dec.h:70
static int b4_mantissas[128][2]
Definition: ac3dec.c:51
LIBAVUTIL_VERSION_INT
Definition: eval.c:50
int channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3dec.h:105
int fbw_channels
number of full-bandwidth channels
Definition: ac3dec.h:137
void(* bit_alloc_calc_bap)(int16_t *mask, int16_t *psd, int start, int end, int snr_offset, int floor, const uint8_t *bap_tab, uint8_t *bap)
Calculate bit allocation pointers.
Definition: ac3dsp.h:106
NULL
Definition: eval.c:50
static const uint16_t dither[8][8]
Definition: vf_gradfun.c:41
uint8_t bap[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
bit allocation pointers
Definition: ac3dec.h:172
#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
int sample_rate
samples per second
Definition: avcodec.h:1456
av_default_item_name
Definition: dnxhdenc.c:43
main external API structure.
Definition: avcodec.h:1329
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:327
#define LEVEL_ZERO
Definition: ac3.h:60
#define LEVEL_ONE
Definition: ac3.h:61
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3dec.h:108
int num_spx_bands
number of spx bands (nspxbnds)
Definition: ac3dec.h:124
#define OFFSET(x)
Definition: ac3dec.c:1459
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:82
static const float gain_levels[9]
Adjustments in dB gain.
Definition: ac3dec.c:67
float tmp_output[AC3_BLOCK_SIZE]
temporary storage for output before windowing
Definition: ac3dec.h:206
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
int b1
Definition: ac3dec.c:424
void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
Apply spectral extension to each channel by copying lower frequency coefficients to higher frequency ...
Definition: eac3dec.c:66
Describe the class of an AVClass context structure.
Definition: log.h:33
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
int bitstream_mode
bitstream mode (bsmod)
Definition: ac3dec.h:82
static void set_downmix_coeffs(AC3DecodeContext *s)
Set stereo downmixing coefficients based on frame header info.
Definition: ac3dec.c:308
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:354
int frame_type
frame type (strmtyp)
Definition: ac3dec.h:76
uint16_t frame_size
Definition: ac3.h:120
static const uint8_t quantization_tab[16]
Quantization table: levels for symmetric.
Definition: ac3dec.c:58
#define AV_EF_CRCCHECK
Definition: avcodec.h:3156
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:132
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:179
static int ac3_parse_header(AC3DecodeContext *s)
Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
Definition: ac3dec.c:208
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
int cpl_in_use[AC3_MAX_BLOCKS]
coupling in use (cplinu)
Definition: ac3dec.h:103
#define v0
Definition: regdef.h:26
int dba_mode[AC3_MAX_CHANNELS]
delta bit allocation mode
Definition: ac3dec.h:176
int first_cpl_leak
first coupling leak state (firstcplleak)
Definition: ac3dec.h:169
void ff_ac3_downmix_c(float(*samples)[256], float(*matrix)[2], int out_ch, int in_ch, int len)
Downmix the output to mono or stereo.
Definition: ac3dec.c:631
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:170
int downmixed
indicates if coeffs are currently downmixed
Definition: ac3dec.h:141
float window[AC3_BLOCK_SIZE]
window coefficients
Definition: ac3dec.h:205
float mul_bias
scaling for float_to_int16 conversion
Definition: ac3dec.h:198
common internal api header.
#define ff_mdct_end
Definition: fft.h:147
void av_cold av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
int surround_mix_level
Surround mix level index.
Definition: ac3.h:108
int num_blocks
number of audio blocks
Definition: ac3dec.h:81
#define AC3_OUTPUT_LFEON
Definition: ac3dec.h:61
AVSampleFormat
all in native-endian format
Definition: samplefmt.h:27
FmtConvertContext fmt_conv
optimized conversion functions
Definition: ac3dec.h:197
int b1_mant[2]
Definition: ac3dec.c:421
float transform_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
transform coefficients
Definition: ac3dec.h:203
int center_mix_level
Center mix level index.
Definition: ac3.h:107
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:133
void * priv_data
Definition: avcodec.h:1531
float spx_noise_blend[AC3_MAX_CHANNELS][SPX_MAX_BANDS]
spx noise blending factor (nblendfact)
Definition: ac3dec.h:127
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:158
int fixed_coeffs[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
fixed-point transform coefficients
Definition: ac3dec.h:202
uint8_t spx_band_sizes[SPX_MAX_BANDS]
number of bins in each spx band
Definition: ac3dec.h:125
static int parse_frame_header(AC3DecodeContext *s)
Common function to parse AC-3 or E-AC-3 frame header.
Definition: ac3dec.c:248
#define LEVEL_PLUS_3DB
Definition: ac3.h:53
int snr_offset_strategy
SNR offset strategy (snroffststr)
Definition: ac3dec.h:93
int b2_mant[2]
Definition: ac3dec.c:422
av_cold void ff_fmt_convert_init(FmtConvertContext *c, AVCodecContext *avctx)
Definition: fmtconvert.c:78
int len
int start_freq[AC3_MAX_CHANNELS]
start frequency bin (strtmant)
Definition: ac3dec.h:152
int substreamid
substream identification
Definition: ac3.h:106
int channels
number of audio channels
Definition: avcodec.h:1457
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:119
int output_mode
output channel configuration
Definition: ac3dec.h:142
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:392
Definition: vf_drawbox.c:32
#define LEVEL_MINUS_6DB
Definition: ac3.h:58
int frame_size
current frame size, in bytes
Definition: ac3dec.h:78
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
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:139
void avcodec_get_frame_defaults(AVFrame *pic)
Set the fields of the given AVFrame to default values.
Definition: utils.c:609
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:120
int num_blocks
number of audio blocks
Definition: ac3.h:110
uint8_t channel_mode
Definition: ac3.h:103
AVLFG dith_state
for dither generation
Definition: ac3dec.h:185
int cpl_strategy_exists[AC3_MAX_BLOCKS]
coupling strategy exists (cplstre)
Definition: ac3dec.h:104
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
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:649
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:1714
static void remove_dithering(AC3DecodeContext *s)
Remove random dithering from coupling range coefficients with zero-bit mantissas for coupled channels...
Definition: ac3dec.c:510
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1265
#define EXP_D45
Definition: ac3.h:50
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:122
int skip_syntax
skip field syntax enabled (skipflde)
Definition: ac3dec.h:99
int b2
Definition: ac3dec.c:425
int8_t dexps[AC3_MAX_CHANNELS][AC3_MAX_COEFS]
decoded exponents
Definition: ac3dec.h:163