FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
33 #include "libavutil/crc.h"
34 #include "libavutil/downmix_info.h"
35 #include "libavutil/opt.h"
36 #include "bswapdsp.h"
37 #include "internal.h"
38 #include "aac_ac3_parser.h"
39 #include "ac3_parser.h"
40 #include "ac3dec.h"
41 #include "ac3dec_data.h"
42 #include "kbdwin.h"
43 
44 /**
45  * table for ungrouping 3 values in 7 bits.
46  * used for exponents and bap=2 mantissas
47  */
49 
50 /** tables for ungrouping mantissas */
51 static int b1_mantissas[32][3];
52 static int b2_mantissas[128][3];
53 static int b3_mantissas[8];
54 static int b4_mantissas[128][2];
55 static int b5_mantissas[16];
56 
57 /**
58  * Quantization table: levels for symmetric. bits for asymmetric.
59  * reference: Table 7.18 Mapping of bap to Quantizer
60  */
61 static const uint8_t quantization_tab[16] = {
62  0, 3, 5, 7, 11, 15,
63  5, 6, 7, 8, 9, 10, 11, 12, 14, 16
64 };
65 
66 /** dynamic range table. converts codes to scale factors. */
67 static float dynamic_range_tab[256];
68 static float heavy_dynamic_range_tab[256];
69 
70 /** Adjustments in dB gain */
71 static const float gain_levels[9] = {
74  LEVEL_ONE,
79  LEVEL_ZERO,
81 };
82 
83 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
84 static const float gain_levels_lfe[32] = {
85  3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
86  1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
87  0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
88  0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
89  0.125892, 0.112201, 0.100000, 0.089125
90 };
91 
92 /**
93  * Table for default stereo downmixing coefficients
94  * reference: Section 7.8.2 Downmixing Into Two Channels
95  */
96 static const uint8_t ac3_default_coeffs[8][5][2] = {
97  { { 2, 7 }, { 7, 2 }, },
98  { { 4, 4 }, },
99  { { 2, 7 }, { 7, 2 }, },
100  { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
101  { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
102  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
103  { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
104  { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
105 };
106 
107 /**
108  * Symmetrical Dequantization
109  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
110  * Tables 7.19 to 7.23
111  */
112 static inline int
113 symmetric_dequant(int code, int levels)
114 {
115  return ((code - (levels >> 1)) * (1 << 24)) / levels;
116 }
117 
118 /*
119  * Initialize tables at runtime.
120  */
121 static av_cold void ac3_tables_init(void)
122 {
123  int i;
124 
125  /* generate table for ungrouping 3 values in 7 bits
126  reference: Section 7.1.3 Exponent Decoding */
127  for (i = 0; i < 128; i++) {
128  ungroup_3_in_7_bits_tab[i][0] = i / 25;
129  ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
130  ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
131  }
132 
133  /* generate grouped mantissa tables
134  reference: Section 7.3.5 Ungrouping of Mantissas */
135  for (i = 0; i < 32; i++) {
136  /* bap=1 mantissas */
140  }
141  for (i = 0; i < 128; i++) {
142  /* bap=2 mantissas */
146 
147  /* bap=4 mantissas */
148  b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
149  b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
150  }
151  /* generate ungrouped mantissa tables
152  reference: Tables 7.21 and 7.23 */
153  for (i = 0; i < 7; i++) {
154  /* bap=3 mantissas */
155  b3_mantissas[i] = symmetric_dequant(i, 7);
156  }
157  for (i = 0; i < 15; i++) {
158  /* bap=5 mantissas */
159  b5_mantissas[i] = symmetric_dequant(i, 15);
160  }
161 
162  /* generate dynamic range table
163  reference: Section 7.7.1 Dynamic Range Control */
164  for (i = 0; i < 256; i++) {
165  int v = (i >> 5) - ((i >> 7) << 3) - 5;
166  dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
167  }
168 
169  /* generate compr dynamic range table
170  reference: Section 7.7.2 Heavy Compression */
171  for (i = 0; i < 256; i++) {
172  int v = (i >> 4) - ((i >> 7) << 4) - 4;
173  heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
174  }
175 
176 }
177 
178 /**
179  * AVCodec initialization
180  */
182 {
183  AC3DecodeContext *s = avctx->priv_data;
184  int i;
185 
186  s->avctx = avctx;
187 
189  ac3_tables_init();
190  ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
191  ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
192  AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
193  ff_bswapdsp_init(&s->bdsp);
194 
195 #if (USE_FIXED)
197 #else
199  ff_fmt_convert_init(&s->fmt_conv, avctx);
200 #endif
201 
203  av_lfg_init(&s->dith_state, 0);
204 
205  if (USE_FIXED)
207  else
209 
210  /* allow downmixing to stereo or mono */
211 #if FF_API_REQUEST_CHANNELS
213  if (avctx->request_channels == 1)
215  else if (avctx->request_channels == 2)
218 #endif
219  if (avctx->channels > 1 &&
221  avctx->channels = 1;
222  else if (avctx->channels > 2 &&
224  avctx->channels = 2;
225  s->downmixed = 1;
226 
227  for (i = 0; i < AC3_MAX_CHANNELS; i++) {
228  s->xcfptr[i] = s->transform_coeffs[i];
229  s->dlyptr[i] = s->delay[i];
230  }
231 
232  return 0;
233 }
234 
235 /**
236  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
237  * GetBitContext within AC3DecodeContext must point to
238  * the start of the synchronized AC-3 bitstream.
239  */
241 {
242  GetBitContext *gbc = &s->gbc;
243  int i;
244 
245  /* read the rest of the bsi. read twice for dual mono mode. */
246  i = !s->channel_mode;
247  do {
248  s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
249  if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
250  s->dialog_normalization[(!s->channel_mode)-i] = -31;
251  }
252  if (s->target_level != 0) {
253  s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
254  (float)(s->target_level -
255  s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
256  }
257  if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
258  s->heavy_dynamic_range[(!s->channel_mode)-i] =
259  AC3_HEAVY_RANGE(get_bits(gbc, 8));
260  }
261  if (get_bits1(gbc))
262  skip_bits(gbc, 8); //skip language code
263  if (get_bits1(gbc))
264  skip_bits(gbc, 7); //skip audio production information
265  } while (i--);
266 
267  skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
268 
269  /* skip the timecodes or parse the Alternate Bit Stream Syntax */
270  if (s->bitstream_id != 6) {
271  if (get_bits1(gbc))
272  skip_bits(gbc, 14); //skip timecode1
273  if (get_bits1(gbc))
274  skip_bits(gbc, 14); //skip timecode2
275  } else {
276  if (get_bits1(gbc)) {
277  s->preferred_downmix = get_bits(gbc, 2);
278  s->center_mix_level_ltrt = get_bits(gbc, 3);
279  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
280  s->center_mix_level = get_bits(gbc, 3);
281  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
282  }
283  if (get_bits1(gbc)) {
284  s->dolby_surround_ex_mode = get_bits(gbc, 2);
285  s->dolby_headphone_mode = get_bits(gbc, 2);
286  skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
287  }
288  }
289 
290  /* skip additional bitstream info */
291  if (get_bits1(gbc)) {
292  i = get_bits(gbc, 6);
293  do {
294  skip_bits(gbc, 8);
295  } while (i--);
296  }
297 
298  return 0;
299 }
300 
301 /**
302  * Common function to parse AC-3 or E-AC-3 frame header
303  */
305 {
306  AC3HeaderInfo hdr, *phdr=&hdr;
307  int err;
308 
309  err = avpriv_ac3_parse_header2(&s->gbc, &phdr);
310  if (err)
311  return err;
312 
313  /* get decoding parameters from header info */
315  s->bitstream_id = hdr.bitstream_id;
317  s->channel_mode = hdr.channel_mode;
318  s->lfe_on = hdr.lfe_on;
320  s->sample_rate = hdr.sample_rate;
321  s->bit_rate = hdr.bit_rate;
322  s->channels = hdr.channels;
323  s->fbw_channels = s->channels - s->lfe_on;
324  s->lfe_ch = s->fbw_channels + 1;
325  s->frame_size = hdr.frame_size;
328  s->center_mix_level_ltrt = 4; // -3.0dB
330  s->surround_mix_level_ltrt = 4; // -3.0dB
331  s->lfe_mix_level_exists = 0;
332  s->num_blocks = hdr.num_blocks;
333  s->frame_type = hdr.frame_type;
334  s->substreamid = hdr.substreamid;
338 
339  if (s->lfe_on) {
340  s->start_freq[s->lfe_ch] = 0;
341  s->end_freq[s->lfe_ch] = 7;
342  s->num_exp_groups[s->lfe_ch] = 2;
343  s->channel_in_cpl[s->lfe_ch] = 0;
344  }
345 
346  if (s->bitstream_id <= 10) {
347  s->eac3 = 0;
348  s->snr_offset_strategy = 2;
349  s->block_switch_syntax = 1;
350  s->dither_flag_syntax = 1;
351  s->bit_allocation_syntax = 1;
352  s->fast_gain_syntax = 0;
353  s->first_cpl_leak = 0;
354  s->dba_syntax = 1;
355  s->skip_syntax = 1;
356  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
357  return ac3_parse_header(s);
358  } else if (CONFIG_EAC3_DECODER) {
359  s->eac3 = 1;
360  return ff_eac3_parse_header(s);
361  } else {
362  av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
363  return AVERROR(ENOSYS);
364  }
365 }
366 
367 /**
368  * Set stereo downmixing coefficients based on frame header info.
369  * reference: Section 7.8.2 Downmixing Into Two Channels
370  */
372 {
373  int i;
374  float cmix = gain_levels[s-> center_mix_level];
375  float smix = gain_levels[s->surround_mix_level];
376  float norm0, norm1;
377  float downmix_coeffs[AC3_MAX_CHANNELS][2];
378 
379  for (i = 0; i < s->fbw_channels; i++) {
380  downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
381  downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
382  }
383  if (s->channel_mode > 1 && s->channel_mode & 1) {
384  downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
385  }
387  int nf = s->channel_mode - 2;
388  downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
389  }
391  int nf = s->channel_mode - 4;
392  downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
393  }
394 
395  /* renormalize */
396  norm0 = norm1 = 0.0;
397  for (i = 0; i < s->fbw_channels; i++) {
398  norm0 += downmix_coeffs[i][0];
399  norm1 += downmix_coeffs[i][1];
400  }
401  norm0 = 1.0f / norm0;
402  norm1 = 1.0f / norm1;
403  for (i = 0; i < s->fbw_channels; i++) {
404  downmix_coeffs[i][0] *= norm0;
405  downmix_coeffs[i][1] *= norm1;
406  }
407 
408  if (s->output_mode == AC3_CHMODE_MONO) {
409  for (i = 0; i < s->fbw_channels; i++)
410  downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
411  downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
412  }
413  for (i = 0; i < s->fbw_channels; i++) {
414  s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
415  s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
416  }
417 }
418 
419 /**
420  * Decode the grouped exponents according to exponent strategy.
421  * reference: Section 7.1.3 Exponent Decoding
422  */
423 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
424  uint8_t absexp, int8_t *dexps)
425 {
426  int i, j, grp, group_size;
427  int dexp[256];
428  int expacc, prevexp;
429 
430  /* unpack groups */
431  group_size = exp_strategy + (exp_strategy == EXP_D45);
432  for (grp = 0, i = 0; grp < ngrps; grp++) {
433  expacc = get_bits(gbc, 7);
434  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
435  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
436  dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
437  }
438 
439  /* convert to absolute exps and expand groups */
440  prevexp = absexp;
441  for (i = 0, j = 0; i < ngrps * 3; i++) {
442  prevexp += dexp[i] - 2;
443  if (prevexp > 24U)
444  return -1;
445  switch (group_size) {
446  case 4: dexps[j++] = prevexp;
447  dexps[j++] = prevexp;
448  case 2: dexps[j++] = prevexp;
449  case 1: dexps[j++] = prevexp;
450  }
451  }
452  return 0;
453 }
454 
455 /**
456  * Generate transform coefficients for each coupled channel in the coupling
457  * range using the coupling coefficients and coupling coordinates.
458  * reference: Section 7.4.3 Coupling Coordinate Format
459  */
461 {
462  int bin, band, ch;
463 
464  bin = s->start_freq[CPL_CH];
465  for (band = 0; band < s->num_cpl_bands; band++) {
466  int band_start = bin;
467  int band_end = bin + s->cpl_band_sizes[band];
468  for (ch = 1; ch <= s->fbw_channels; ch++) {
469  if (s->channel_in_cpl[ch]) {
470  int cpl_coord = s->cpl_coords[ch][band] << 5;
471  for (bin = band_start; bin < band_end; bin++) {
472  s->fixed_coeffs[ch][bin] =
473  MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
474  }
475  if (ch == 2 && s->phase_flags[band]) {
476  for (bin = band_start; bin < band_end; bin++)
477  s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
478  }
479  }
480  }
481  bin = band_end;
482  }
483 }
484 
485 /**
486  * Grouped mantissas for 3-level 5-level and 11-level quantization
487  */
488 typedef struct mant_groups {
489  int b1_mant[2];
490  int b2_mant[2];
491  int b4_mant;
492  int b1;
493  int b2;
494  int b4;
495 } mant_groups;
496 
497 /**
498  * Decode the transform coefficients for a particular channel
499  * reference: Section 7.3 Quantization and Decoding of Mantissas
500  */
502 {
503  int start_freq = s->start_freq[ch_index];
504  int end_freq = s->end_freq[ch_index];
505  uint8_t *baps = s->bap[ch_index];
506  int8_t *exps = s->dexps[ch_index];
507  int32_t *coeffs = s->fixed_coeffs[ch_index];
508  int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
509  GetBitContext *gbc = &s->gbc;
510  int freq;
511 
512  for (freq = start_freq; freq < end_freq; freq++) {
513  int bap = baps[freq];
514  int mantissa;
515  switch (bap) {
516  case 0:
517  /* random noise with approximate range of -0.707 to 0.707 */
518  if (dither)
519  mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
520  else
521  mantissa = 0;
522  break;
523  case 1:
524  if (m->b1) {
525  m->b1--;
526  mantissa = m->b1_mant[m->b1];
527  } else {
528  int bits = get_bits(gbc, 5);
529  mantissa = b1_mantissas[bits][0];
530  m->b1_mant[1] = b1_mantissas[bits][1];
531  m->b1_mant[0] = b1_mantissas[bits][2];
532  m->b1 = 2;
533  }
534  break;
535  case 2:
536  if (m->b2) {
537  m->b2--;
538  mantissa = m->b2_mant[m->b2];
539  } else {
540  int bits = get_bits(gbc, 7);
541  mantissa = b2_mantissas[bits][0];
542  m->b2_mant[1] = b2_mantissas[bits][1];
543  m->b2_mant[0] = b2_mantissas[bits][2];
544  m->b2 = 2;
545  }
546  break;
547  case 3:
548  mantissa = b3_mantissas[get_bits(gbc, 3)];
549  break;
550  case 4:
551  if (m->b4) {
552  m->b4 = 0;
553  mantissa = m->b4_mant;
554  } else {
555  int bits = get_bits(gbc, 7);
556  mantissa = b4_mantissas[bits][0];
557  m->b4_mant = b4_mantissas[bits][1];
558  m->b4 = 1;
559  }
560  break;
561  case 5:
562  mantissa = b5_mantissas[get_bits(gbc, 4)];
563  break;
564  default: /* 6 to 15 */
565  /* Shift mantissa and sign-extend it. */
566  if (bap > 15) {
567  av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
568  bap = 15;
569  }
570  mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
571  break;
572  }
573  coeffs[freq] = mantissa >> exps[freq];
574  }
575 }
576 
577 /**
578  * Remove random dithering from coupling range coefficients with zero-bit
579  * mantissas for coupled channels which do not use dithering.
580  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
581  */
583  int ch, i;
584 
585  for (ch = 1; ch <= s->fbw_channels; ch++) {
586  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
587  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
588  if (!s->bap[CPL_CH][i])
589  s->fixed_coeffs[ch][i] = 0;
590  }
591  }
592  }
593 }
594 
596  mant_groups *m)
597 {
598  if (!s->channel_uses_aht[ch]) {
600  } else {
601  /* if AHT is used, mantissas for all blocks are encoded in the first
602  block of the frame. */
603  int bin;
604  if (CONFIG_EAC3_DECODER && !blk)
606  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
607  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
608  }
609  }
610 }
611 
612 /**
613  * Decode the transform coefficients.
614  */
616 {
617  int ch, end;
618  int got_cplchan = 0;
619  mant_groups m;
620 
621  m.b1 = m.b2 = m.b4 = 0;
622 
623  for (ch = 1; ch <= s->channels; ch++) {
624  /* transform coefficients for full-bandwidth channel */
625  decode_transform_coeffs_ch(s, blk, ch, &m);
626  /* transform coefficients for coupling channel come right after the
627  coefficients for the first coupled channel*/
628  if (s->channel_in_cpl[ch]) {
629  if (!got_cplchan) {
630  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
632  got_cplchan = 1;
633  }
634  end = s->end_freq[CPL_CH];
635  } else {
636  end = s->end_freq[ch];
637  }
638  do
639  s->fixed_coeffs[ch][end] = 0;
640  while (++end < 256);
641  }
642 
643  /* zero the dithered coefficients for appropriate channels */
644  remove_dithering(s);
645 }
646 
647 /**
648  * Stereo rematrixing.
649  * reference: Section 7.5.4 Rematrixing : Decoding Technique
650  */
652 {
653  int bnd, i;
654  int end, bndend;
655 
656  end = FFMIN(s->end_freq[1], s->end_freq[2]);
657 
658  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
659  if (s->rematrixing_flags[bnd]) {
660  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
661  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
662  int tmp0 = s->fixed_coeffs[1][i];
663  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
664  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
665  }
666  }
667  }
668 }
669 
670 /**
671  * Inverse MDCT Transform.
672  * Convert frequency domain coefficients to time-domain audio samples.
673  * reference: Section 7.9.4 Transformation Equations
674  */
675 static inline void do_imdct(AC3DecodeContext *s, int channels)
676 {
677  int ch;
678 
679  for (ch = 1; ch <= channels; ch++) {
680  if (s->block_switch[ch]) {
681  int i;
682  FFTSample *x = s->tmp_output + 128;
683  for (i = 0; i < 128; i++)
684  x[i] = s->transform_coeffs[ch][2 * i];
685  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
686 #if USE_FIXED
687  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
688  s->tmp_output, s->window, 128, 8);
689 #else
690  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
691  s->tmp_output, s->window, 128);
692 #endif
693  for (i = 0; i < 128; i++)
694  x[i] = s->transform_coeffs[ch][2 * i + 1];
695  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
696  } else {
698 #if USE_FIXED
699  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
700  s->tmp_output, s->window, 128, 8);
701 #else
702  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
703  s->tmp_output, s->window, 128);
704 #endif
705  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
706  }
707  }
708 }
709 
710 /**
711  * Upmix delay samples from stereo to original channel layout.
712  */
714 {
715  int channel_data_size = sizeof(s->delay[0]);
716  switch (s->channel_mode) {
717  case AC3_CHMODE_DUALMONO:
718  case AC3_CHMODE_STEREO:
719  /* upmix mono to stereo */
720  memcpy(s->delay[1], s->delay[0], channel_data_size);
721  break;
722  case AC3_CHMODE_2F2R:
723  memset(s->delay[3], 0, channel_data_size);
724  case AC3_CHMODE_2F1R:
725  memset(s->delay[2], 0, channel_data_size);
726  break;
727  case AC3_CHMODE_3F2R:
728  memset(s->delay[4], 0, channel_data_size);
729  case AC3_CHMODE_3F1R:
730  memset(s->delay[3], 0, channel_data_size);
731  case AC3_CHMODE_3F:
732  memcpy(s->delay[2], s->delay[1], channel_data_size);
733  memset(s->delay[1], 0, channel_data_size);
734  break;
735  }
736 }
737 
738 /**
739  * Decode band structure for coupling, spectral extension, or enhanced coupling.
740  * The band structure defines how many subbands are in each band. For each
741  * subband in the range, 1 means it is combined with the previous band, and 0
742  * means that it starts a new band.
743  *
744  * @param[in] gbc bit reader context
745  * @param[in] blk block number
746  * @param[in] eac3 flag to indicate E-AC-3
747  * @param[in] ecpl flag to indicate enhanced coupling
748  * @param[in] start_subband subband number for start of range
749  * @param[in] end_subband subband number for end of range
750  * @param[in] default_band_struct default band structure table
751  * @param[out] num_bands number of bands (optionally NULL)
752  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
753  */
754 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
755  int ecpl, int start_subband, int end_subband,
756  const uint8_t *default_band_struct,
757  int *num_bands, uint8_t *band_sizes)
758 {
759  int subbnd, bnd, n_subbands, n_bands=0;
760  uint8_t bnd_sz[22];
761  uint8_t coded_band_struct[22];
762  const uint8_t *band_struct;
763 
764  n_subbands = end_subband - start_subband;
765 
766  /* decode band structure from bitstream or use default */
767  if (!eac3 || get_bits1(gbc)) {
768  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
769  coded_band_struct[subbnd] = get_bits1(gbc);
770  }
771  band_struct = coded_band_struct;
772  } else if (!blk) {
773  band_struct = &default_band_struct[start_subband+1];
774  } else {
775  /* no change in band structure */
776  return;
777  }
778 
779  /* calculate number of bands and band sizes based on band structure.
780  note that the first 4 subbands in enhanced coupling span only 6 bins
781  instead of 12. */
782  if (num_bands || band_sizes ) {
783  n_bands = n_subbands;
784  bnd_sz[0] = ecpl ? 6 : 12;
785  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
786  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
787  if (band_struct[subbnd - 1]) {
788  n_bands--;
789  bnd_sz[bnd] += subbnd_size;
790  } else {
791  bnd_sz[++bnd] = subbnd_size;
792  }
793  }
794  }
795 
796  /* set optional output params */
797  if (num_bands)
798  *num_bands = n_bands;
799  if (band_sizes)
800  memcpy(band_sizes, bnd_sz, n_bands);
801 }
802 
803 /**
804  * Decode a single audio block from the AC-3 bitstream.
805  */
807 {
808  int fbw_channels = s->fbw_channels;
809  int channel_mode = s->channel_mode;
810  int i, bnd, seg, ch;
811  int different_transforms;
812  int downmix_output;
813  int cpl_in_use;
814  GetBitContext *gbc = &s->gbc;
815  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
816 
817  /* block switch flags */
818  different_transforms = 0;
819  if (s->block_switch_syntax) {
820  for (ch = 1; ch <= fbw_channels; ch++) {
821  s->block_switch[ch] = get_bits1(gbc);
822  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
823  different_transforms = 1;
824  }
825  }
826 
827  /* dithering flags */
828  if (s->dither_flag_syntax) {
829  for (ch = 1; ch <= fbw_channels; ch++) {
830  s->dither_flag[ch] = get_bits1(gbc);
831  }
832  }
833 
834  /* dynamic range */
835  i = !s->channel_mode;
836  do {
837  if (get_bits1(gbc)) {
838  /* Allow asymmetric application of DRC when drc_scale > 1.
839  Amplification of quiet sounds is enhanced */
840  int range_bits = get_bits(gbc, 8);
841  INTFLOAT range = AC3_RANGE(range_bits);
842  if (range_bits <= 127 || s->drc_scale <= 1.0)
843  s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
844  else
845  s->dynamic_range[i] = range;
846  } else if (blk == 0) {
848  }
849  } while (i--);
850 
851  /* spectral extension strategy */
852  if (s->eac3 && (!blk || get_bits1(gbc))) {
853  s->spx_in_use = get_bits1(gbc);
854  if (s->spx_in_use) {
855  int dst_start_freq, dst_end_freq, src_start_freq,
856  start_subband, end_subband;
857 
858  /* determine which channels use spx */
859  if (s->channel_mode == AC3_CHMODE_MONO) {
860  s->channel_uses_spx[1] = 1;
861  } else {
862  for (ch = 1; ch <= fbw_channels; ch++)
863  s->channel_uses_spx[ch] = get_bits1(gbc);
864  }
865 
866  /* get the frequency bins of the spx copy region and the spx start
867  and end subbands */
868  dst_start_freq = get_bits(gbc, 2);
869  start_subband = get_bits(gbc, 3) + 2;
870  if (start_subband > 7)
871  start_subband += start_subband - 7;
872  end_subband = get_bits(gbc, 3) + 5;
873 #if USE_FIXED
874  s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
875 #endif
876  if (end_subband > 7)
877  end_subband += end_subband - 7;
878  dst_start_freq = dst_start_freq * 12 + 25;
879  src_start_freq = start_subband * 12 + 25;
880  dst_end_freq = end_subband * 12 + 25;
881 
882  /* check validity of spx ranges */
883  if (start_subband >= end_subband) {
884  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
885  "range (%d >= %d)\n", start_subband, end_subband);
886  return AVERROR_INVALIDDATA;
887  }
888  if (dst_start_freq >= src_start_freq) {
889  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
890  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
891  return AVERROR_INVALIDDATA;
892  }
893 
894  s->spx_dst_start_freq = dst_start_freq;
895  s->spx_src_start_freq = src_start_freq;
896  if (!USE_FIXED)
897  s->spx_dst_end_freq = dst_end_freq;
898 
899  decode_band_structure(gbc, blk, s->eac3, 0,
900  start_subband, end_subband,
902  &s->num_spx_bands,
903  s->spx_band_sizes);
904  } else {
905  for (ch = 1; ch <= fbw_channels; ch++) {
906  s->channel_uses_spx[ch] = 0;
907  s->first_spx_coords[ch] = 1;
908  }
909  }
910  }
911 
912  /* spectral extension coordinates */
913  if (s->spx_in_use) {
914  for (ch = 1; ch <= fbw_channels; ch++) {
915  if (s->channel_uses_spx[ch]) {
916  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
917  INTFLOAT spx_blend;
918  int bin, master_spx_coord;
919 
920  s->first_spx_coords[ch] = 0;
921  spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
922  master_spx_coord = get_bits(gbc, 2) * 3;
923 
924  bin = s->spx_src_start_freq;
925  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
926  int bandsize = s->spx_band_sizes[bnd];
927  int spx_coord_exp, spx_coord_mant;
928  INTFLOAT nratio, sblend, nblend;
929 #if USE_FIXED
930  /* calculate blending factors */
931  int64_t accu = ((bin << 23) + (bandsize << 22))
932  * (int64_t)s->spx_dst_end_freq;
933  nratio = (int)(accu >> 32);
934  nratio -= spx_blend << 18;
935 
936  if (nratio < 0) {
937  nblend = 0;
938  sblend = 0x800000;
939  } else if (nratio > 0x7fffff) {
940  nblend = 14529495; // sqrt(3) in FP.23
941  sblend = 0;
942  } else {
943  nblend = fixed_sqrt(nratio, 23);
944  accu = (int64_t)nblend * 1859775393;
945  nblend = (int)((accu + (1<<29)) >> 30);
946  sblend = fixed_sqrt(0x800000 - nratio, 23);
947  }
948 #else
949  float spx_coord;
950 
951  /* calculate blending factors */
952  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
953  nratio = av_clipf(nratio, 0.0f, 1.0f);
954  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
955  // to give unity variance
956  sblend = sqrtf(1.0f - nratio);
957 #endif
958  bin += bandsize;
959 
960  /* decode spx coordinates */
961  spx_coord_exp = get_bits(gbc, 4);
962  spx_coord_mant = get_bits(gbc, 2);
963  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
964  else spx_coord_mant += 4;
965  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
966 
967  /* multiply noise and signal blending factors by spx coordinate */
968 #if USE_FIXED
969  accu = (int64_t)nblend * spx_coord_mant;
970  s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
971  accu = (int64_t)sblend * spx_coord_mant;
972  s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
973 #else
974  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
975  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
976  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
977 #endif
978  }
979  }
980  } else {
981  s->first_spx_coords[ch] = 1;
982  }
983  }
984  }
985 
986  /* coupling strategy */
987  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
988  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
989  if (!s->eac3)
990  s->cpl_in_use[blk] = get_bits1(gbc);
991  if (s->cpl_in_use[blk]) {
992  /* coupling in use */
993  int cpl_start_subband, cpl_end_subband;
994 
995  if (channel_mode < AC3_CHMODE_STEREO) {
996  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
997  return AVERROR_INVALIDDATA;
998  }
999 
1000  /* check for enhanced coupling */
1001  if (s->eac3 && get_bits1(gbc)) {
1002  /* TODO: parse enhanced coupling strategy info */
1003  avpriv_request_sample(s->avctx, "Enhanced coupling");
1004  return AVERROR_PATCHWELCOME;
1005  }
1006 
1007  /* determine which channels are coupled */
1008  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
1009  s->channel_in_cpl[1] = 1;
1010  s->channel_in_cpl[2] = 1;
1011  } else {
1012  for (ch = 1; ch <= fbw_channels; ch++)
1013  s->channel_in_cpl[ch] = get_bits1(gbc);
1014  }
1015 
1016  /* phase flags in use */
1017  if (channel_mode == AC3_CHMODE_STEREO)
1018  s->phase_flags_in_use = get_bits1(gbc);
1019 
1020  /* coupling frequency range */
1021  cpl_start_subband = get_bits(gbc, 4);
1022  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1023  get_bits(gbc, 4) + 3;
1024  if (cpl_start_subband >= cpl_end_subband) {
1025  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1026  cpl_start_subband, cpl_end_subband);
1027  return AVERROR_INVALIDDATA;
1028  }
1029  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1030  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1031 
1032  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1033  cpl_end_subband,
1035  &s->num_cpl_bands, s->cpl_band_sizes);
1036  } else {
1037  /* coupling not in use */
1038  for (ch = 1; ch <= fbw_channels; ch++) {
1039  s->channel_in_cpl[ch] = 0;
1040  s->first_cpl_coords[ch] = 1;
1041  }
1042  s->first_cpl_leak = s->eac3;
1043  s->phase_flags_in_use = 0;
1044  }
1045  } else if (!s->eac3) {
1046  if (!blk) {
1047  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1048  "be present in block 0\n");
1049  return AVERROR_INVALIDDATA;
1050  } else {
1051  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1052  }
1053  }
1054  cpl_in_use = s->cpl_in_use[blk];
1055 
1056  /* coupling coordinates */
1057  if (cpl_in_use) {
1058  int cpl_coords_exist = 0;
1059 
1060  for (ch = 1; ch <= fbw_channels; ch++) {
1061  if (s->channel_in_cpl[ch]) {
1062  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1063  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1064  s->first_cpl_coords[ch] = 0;
1065  cpl_coords_exist = 1;
1066  master_cpl_coord = 3 * get_bits(gbc, 2);
1067  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1068  cpl_coord_exp = get_bits(gbc, 4);
1069  cpl_coord_mant = get_bits(gbc, 4);
1070  if (cpl_coord_exp == 15)
1071  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1072  else
1073  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1074  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1075  }
1076  } else if (!blk) {
1077  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1078  "be present in block 0\n");
1079  return AVERROR_INVALIDDATA;
1080  }
1081  } else {
1082  /* channel not in coupling */
1083  s->first_cpl_coords[ch] = 1;
1084  }
1085  }
1086  /* phase flags */
1087  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1088  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1089  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1090  }
1091  }
1092  }
1093 
1094  /* stereo rematrixing strategy and band structure */
1095  if (channel_mode == AC3_CHMODE_STEREO) {
1096  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1097  s->num_rematrixing_bands = 4;
1098  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1099  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1100  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1101  s->num_rematrixing_bands--;
1102  }
1103  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1104  s->rematrixing_flags[bnd] = get_bits1(gbc);
1105  } else if (!blk) {
1106  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1107  "new rematrixing strategy not present in block 0\n");
1108  s->num_rematrixing_bands = 0;
1109  }
1110  }
1111 
1112  /* exponent strategies for each channel */
1113  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1114  if (!s->eac3)
1115  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1116  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1117  bit_alloc_stages[ch] = 3;
1118  }
1119 
1120  /* channel bandwidth */
1121  for (ch = 1; ch <= fbw_channels; ch++) {
1122  s->start_freq[ch] = 0;
1123  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1124  int group_size;
1125  int prev = s->end_freq[ch];
1126  if (s->channel_in_cpl[ch])
1127  s->end_freq[ch] = s->start_freq[CPL_CH];
1128  else if (s->channel_uses_spx[ch])
1129  s->end_freq[ch] = s->spx_src_start_freq;
1130  else {
1131  int bandwidth_code = get_bits(gbc, 6);
1132  if (bandwidth_code > 60) {
1133  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1134  return AVERROR_INVALIDDATA;
1135  }
1136  s->end_freq[ch] = bandwidth_code * 3 + 73;
1137  }
1138  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1139  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1140  if (blk > 0 && s->end_freq[ch] != prev)
1141  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1142  }
1143  }
1144  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1146  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1147  }
1148 
1149  /* decode exponents for each channel */
1150  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1151  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1152  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1153  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1154  s->num_exp_groups[ch], s->dexps[ch][0],
1155  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1156  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1157  return AVERROR_INVALIDDATA;
1158  }
1159  if (ch != CPL_CH && ch != s->lfe_ch)
1160  skip_bits(gbc, 2); /* skip gainrng */
1161  }
1162  }
1163 
1164  /* bit allocation information */
1165  if (s->bit_allocation_syntax) {
1166  if (get_bits1(gbc)) {
1172  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1173  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1174  } else if (!blk) {
1175  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1176  "be present in block 0\n");
1177  return AVERROR_INVALIDDATA;
1178  }
1179  }
1180 
1181  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1182  if (!s->eac3 || !blk) {
1183  if (s->snr_offset_strategy && get_bits1(gbc)) {
1184  int snr = 0;
1185  int csnr;
1186  csnr = (get_bits(gbc, 6) - 15) << 4;
1187  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1188  /* snr offset */
1189  if (ch == i || s->snr_offset_strategy == 2)
1190  snr = (csnr + get_bits(gbc, 4)) << 2;
1191  /* run at least last bit allocation stage if snr offset changes */
1192  if (blk && s->snr_offset[ch] != snr) {
1193  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1194  }
1195  s->snr_offset[ch] = snr;
1196 
1197  /* fast gain (normal AC-3 only) */
1198  if (!s->eac3) {
1199  int prev = s->fast_gain[ch];
1200  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1201  /* run last 2 bit allocation stages if fast gain changes */
1202  if (blk && prev != s->fast_gain[ch])
1203  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1204  }
1205  }
1206  } else if (!s->eac3 && !blk) {
1207  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1208  return AVERROR_INVALIDDATA;
1209  }
1210  }
1211 
1212  /* fast gain (E-AC-3 only) */
1213  if (s->fast_gain_syntax && get_bits1(gbc)) {
1214  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1215  int prev = s->fast_gain[ch];
1216  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1217  /* run last 2 bit allocation stages if fast gain changes */
1218  if (blk && prev != s->fast_gain[ch])
1219  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1220  }
1221  } else if (s->eac3 && !blk) {
1222  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1223  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1224  }
1225 
1226  /* E-AC-3 to AC-3 converter SNR offset */
1227  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1228  skip_bits(gbc, 10); // skip converter snr offset
1229  }
1230 
1231  /* coupling leak information */
1232  if (cpl_in_use) {
1233  if (s->first_cpl_leak || get_bits1(gbc)) {
1234  int fl = get_bits(gbc, 3);
1235  int sl = get_bits(gbc, 3);
1236  /* run last 2 bit allocation stages for coupling channel if
1237  coupling leak changes */
1238  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1239  sl != s->bit_alloc_params.cpl_slow_leak)) {
1240  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1241  }
1244  } else if (!s->eac3 && !blk) {
1245  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1246  "be present in block 0\n");
1247  return AVERROR_INVALIDDATA;
1248  }
1249  s->first_cpl_leak = 0;
1250  }
1251 
1252  /* delta bit allocation information */
1253  if (s->dba_syntax && get_bits1(gbc)) {
1254  /* delta bit allocation exists (strategy) */
1255  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1256  s->dba_mode[ch] = get_bits(gbc, 2);
1257  if (s->dba_mode[ch] == DBA_RESERVED) {
1258  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1259  return AVERROR_INVALIDDATA;
1260  }
1261  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1262  }
1263  /* channel delta offset, len and bit allocation */
1264  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1265  if (s->dba_mode[ch] == DBA_NEW) {
1266  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1267  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1268  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1269  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1270  s->dba_values[ch][seg] = get_bits(gbc, 3);
1271  }
1272  /* run last 2 bit allocation stages if new dba values */
1273  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1274  }
1275  }
1276  } else if (blk == 0) {
1277  for (ch = 0; ch <= s->channels; ch++) {
1278  s->dba_mode[ch] = DBA_NONE;
1279  }
1280  }
1281 
1282  /* Bit allocation */
1283  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1284  if (bit_alloc_stages[ch] > 2) {
1285  /* Exponent mapping into PSD and PSD integration */
1287  s->start_freq[ch], s->end_freq[ch],
1288  s->psd[ch], s->band_psd[ch]);
1289  }
1290  if (bit_alloc_stages[ch] > 1) {
1291  /* Compute excitation function, Compute masking curve, and
1292  Apply delta bit allocation */
1294  s->start_freq[ch], s->end_freq[ch],
1295  s->fast_gain[ch], (ch == s->lfe_ch),
1296  s->dba_mode[ch], s->dba_nsegs[ch],
1297  s->dba_offsets[ch], s->dba_lengths[ch],
1298  s->dba_values[ch], s->mask[ch])) {
1299  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1300  return AVERROR_INVALIDDATA;
1301  }
1302  }
1303  if (bit_alloc_stages[ch] > 0) {
1304  /* Compute bit allocation */
1305  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1307  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1308  s->start_freq[ch], s->end_freq[ch],
1309  s->snr_offset[ch],
1311  bap_tab, s->bap[ch]);
1312  }
1313  }
1314 
1315  /* unused dummy data */
1316  if (s->skip_syntax && get_bits1(gbc)) {
1317  int skipl = get_bits(gbc, 9);
1318  while (skipl--)
1319  skip_bits(gbc, 8);
1320  }
1321 
1322  /* unpack the transform coefficients
1323  this also uncouples channels if coupling is in use. */
1324  decode_transform_coeffs(s, blk);
1325 
1326  /* TODO: generate enhanced coupling coordinates and uncouple */
1327 
1328  /* recover coefficients if rematrixing is in use */
1329  if (s->channel_mode == AC3_CHMODE_STEREO)
1330  do_rematrixing(s);
1331 
1332  /* apply scaling to coefficients (headroom, dynrng) */
1333  for (ch = 1; ch <= s->channels; ch++) {
1334  int audio_channel = 0;
1335  INTFLOAT gain;
1337  audio_channel = 2-ch;
1338  if (s->heavy_compression && s->compression_exists[audio_channel])
1339  gain = s->heavy_dynamic_range[audio_channel];
1340  else
1341  gain = s->dynamic_range[audio_channel];
1342 
1343 #if USE_FIXED
1344  scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1345 #else
1346  if (s->target_level != 0)
1347  gain = gain * s->level_gain[audio_channel];
1348  gain *= 1.0 / 4194304.0f;
1350  s->fixed_coeffs[ch], gain, 256);
1351 #endif
1352  }
1353 
1354  /* apply spectral extension to high frequency bins */
1355  if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1357  }
1358 
1359  /* downmix and MDCT. order depends on whether block switching is used for
1360  any channel in this block. this is because coefficients for the long
1361  and short transforms cannot be mixed. */
1362  downmix_output = s->channels != s->out_channels &&
1363  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1364  s->fbw_channels == s->out_channels);
1365  if (different_transforms) {
1366  /* the delay samples have already been downmixed, so we upmix the delay
1367  samples in order to reconstruct all channels before downmixing. */
1368  if (s->downmixed) {
1369  s->downmixed = 0;
1370  ac3_upmix_delay(s);
1371  }
1372 
1373  do_imdct(s, s->channels);
1374 
1375  if (downmix_output) {
1376 #if USE_FIXED
1378  s->out_channels, s->fbw_channels, 256);
1379 #else
1380  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1381  s->out_channels, s->fbw_channels, 256);
1382 #endif
1383  }
1384  } else {
1385  if (downmix_output) {
1386  s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1387  s->out_channels, s->fbw_channels, 256);
1388  }
1389 
1390  if (downmix_output && !s->downmixed) {
1391  s->downmixed = 1;
1392  s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1393  s->out_channels, s->fbw_channels, 128);
1394  }
1395 
1396  do_imdct(s, s->out_channels);
1397  }
1398 
1399  return 0;
1400 }
1401 
1402 /**
1403  * Decode a single AC-3 frame.
1404  */
1405 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1406  int *got_frame_ptr, AVPacket *avpkt)
1407 {
1408  AVFrame *frame = data;
1409  const uint8_t *buf = avpkt->data;
1410  int buf_size = avpkt->size;
1411  AC3DecodeContext *s = avctx->priv_data;
1412  int blk, ch, err, ret;
1413  const uint8_t *channel_map;
1414  const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1415  enum AVMatrixEncoding matrix_encoding;
1416  AVDownmixInfo *downmix_info;
1417 
1418  /* copy input buffer to decoder context to avoid reading past the end
1419  of the buffer, which can be caused by a damaged input stream. */
1420  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1421  // seems to be byte-swapped AC-3
1422  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1423  s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1424  (const uint16_t *) buf, cnt);
1425  } else
1426  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1427  buf = s->input_buffer;
1428  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1429  if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1430  return ret;
1431 
1432  /* parse the syncinfo */
1433  err = parse_frame_header(s);
1434 
1435  if (err) {
1436  switch (err) {
1438  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1439  return AVERROR_INVALIDDATA;
1441  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1442  break;
1444  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1445  break;
1447  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1448  break;
1450  /* skip frame if CRC is ok. otherwise use error concealment. */
1451  /* TODO: add support for substreams and dependent frames */
1453  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1454  "skipping frame\n");
1455  *got_frame_ptr = 0;
1456  return buf_size;
1457  } else {
1458  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1459  }
1460  break;
1463  break;
1464  default: // Normal AVERROR do not try to recover.
1465  *got_frame_ptr = 0;
1466  return err;
1467  }
1468  } else {
1469  /* check that reported frame size fits in input buffer */
1470  if (s->frame_size > buf_size) {
1471  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1473  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1474  /* check for crc mismatch */
1475  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1476  s->frame_size - 2)) {
1477  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1478  if (avctx->err_recognition & AV_EF_EXPLODE)
1479  return AVERROR_INVALIDDATA;
1481  }
1482  }
1483  }
1484 
1485  /* if frame is ok, set audio parameters */
1486  if (!err) {
1487  avctx->sample_rate = s->sample_rate;
1488  avctx->bit_rate = s->bit_rate;
1489  }
1490 
1491  /* channel config */
1492  if (!err || (s->channels && s->out_channels != s->channels)) {
1493  s->out_channels = s->channels;
1494  s->output_mode = s->channel_mode;
1495  if (s->lfe_on)
1497  if (s->channels > 1 &&
1499  s->out_channels = 1;
1501  } else if (s->channels > 2 &&
1503  s->out_channels = 2;
1505  }
1506 
1507  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1511  /* set downmixing coefficients if needed */
1512  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1513  s->fbw_channels == s->out_channels)) {
1514  set_downmix_coeffs(s);
1515  }
1516  } else if (!s->channels) {
1517  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1518  return AVERROR_INVALIDDATA;
1519  }
1520  avctx->channels = s->out_channels;
1522  if (s->output_mode & AC3_OUTPUT_LFEON)
1524 
1525  /* set audio service type based on bitstream mode for AC-3 */
1526  avctx->audio_service_type = s->bitstream_mode;
1527  if (s->bitstream_mode == 0x7 && s->channels > 1)
1529 
1530  /* get output buffer */
1531  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1532  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1533  return ret;
1534 
1535  /* decode the audio blocks */
1536  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1537  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1538  output[ch] = s->output[ch];
1539  s->outptr[ch] = s->output[ch];
1540  }
1541  for (ch = 0; ch < s->channels; ch++) {
1542  if (ch < s->out_channels)
1543  s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1544  }
1545  for (blk = 0; blk < s->num_blocks; blk++) {
1546  if (!err && decode_audio_block(s, blk)) {
1547  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1548  err = 1;
1549  }
1550  if (err)
1551  for (ch = 0; ch < s->out_channels; ch++)
1552  memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1553  for (ch = 0; ch < s->out_channels; ch++)
1554  output[ch] = s->outptr[channel_map[ch]];
1555  for (ch = 0; ch < s->out_channels; ch++) {
1556  if (!ch || channel_map[ch])
1557  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1558  }
1559  }
1560 
1562 
1563  /* keep last block for error concealment in next frame */
1564  for (ch = 0; ch < s->out_channels; ch++)
1565  memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1566 
1567  /*
1568  * AVMatrixEncoding
1569  *
1570  * Check whether the input layout is compatible, and make sure we're not
1571  * downmixing (else the matrix encoding is no longer applicable).
1572  */
1573  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1574  if (s->channel_mode == AC3_CHMODE_STEREO &&
1575  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1577  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1579  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1580  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1581  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1582  switch (s->dolby_surround_ex_mode) {
1583  case AC3_DSUREXMOD_ON: // EX or PLIIx
1584  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1585  break;
1586  case AC3_DSUREXMOD_PLIIZ:
1587  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1588  break;
1589  default: // not indicated or off
1590  break;
1591  }
1592  }
1593  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1594  return ret;
1595 
1596  /* AVDownmixInfo */
1597  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1598  switch (s->preferred_downmix) {
1599  case AC3_DMIXMOD_LTRT:
1601  break;
1602  case AC3_DMIXMOD_LORO:
1604  break;
1605  case AC3_DMIXMOD_DPLII:
1607  break;
1608  default:
1610  break;
1611  }
1612  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1613  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1614  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1616  if (s->lfe_mix_level_exists)
1617  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1618  else
1619  downmix_info->lfe_mix_level = 0.0; // -inf dB
1620  } else
1621  return AVERROR(ENOMEM);
1622 
1623  *got_frame_ptr = 1;
1624 
1625  return FFMIN(buf_size, s->frame_size);
1626 }
1627 
1628 /**
1629  * Uninitialize the AC-3 decoder.
1630  */
1632 {
1633  AC3DecodeContext *s = avctx->priv_data;
1634  ff_mdct_end(&s->imdct_512);
1635  ff_mdct_end(&s->imdct_256);
1636  av_freep(&s->fdsp);
1637 
1638  return 0;
1639 }
1640 
1641 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1642 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)