FFmpeg  2.6.9
 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)) << 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 #endif
200 
202  ff_fmt_convert_init(&s->fmt_conv, avctx);
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] << 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 = get_sbits(gbc, quantization_tab[bap]);
571  mantissa <<= 24 - quantization_tab[bap];
572  break;
573  }
574  coeffs[freq] = mantissa >> exps[freq];
575  }
576 }
577 
578 /**
579  * Remove random dithering from coupling range coefficients with zero-bit
580  * mantissas for coupled channels which do not use dithering.
581  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
582  */
584  int ch, i;
585 
586  for (ch = 1; ch <= s->fbw_channels; ch++) {
587  if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
588  for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
589  if (!s->bap[CPL_CH][i])
590  s->fixed_coeffs[ch][i] = 0;
591  }
592  }
593  }
594 }
595 
597  mant_groups *m)
598 {
599  if (!s->channel_uses_aht[ch]) {
601  } else {
602  /* if AHT is used, mantissas for all blocks are encoded in the first
603  block of the frame. */
604  int bin;
605  if (!blk && CONFIG_EAC3_DECODER)
607  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
608  s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
609  }
610  }
611 }
612 
613 /**
614  * Decode the transform coefficients.
615  */
617 {
618  int ch, end;
619  int got_cplchan = 0;
620  mant_groups m;
621 
622  m.b1 = m.b2 = m.b4 = 0;
623 
624  for (ch = 1; ch <= s->channels; ch++) {
625  /* transform coefficients for full-bandwidth channel */
626  decode_transform_coeffs_ch(s, blk, ch, &m);
627  /* transform coefficients for coupling channel come right after the
628  coefficients for the first coupled channel*/
629  if (s->channel_in_cpl[ch]) {
630  if (!got_cplchan) {
631  decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
633  got_cplchan = 1;
634  }
635  end = s->end_freq[CPL_CH];
636  } else {
637  end = s->end_freq[ch];
638  }
639  do
640  s->fixed_coeffs[ch][end] = 0;
641  while (++end < 256);
642  }
643 
644  /* zero the dithered coefficients for appropriate channels */
645  remove_dithering(s);
646 }
647 
648 /**
649  * Stereo rematrixing.
650  * reference: Section 7.5.4 Rematrixing : Decoding Technique
651  */
653 {
654  int bnd, i;
655  int end, bndend;
656 
657  end = FFMIN(s->end_freq[1], s->end_freq[2]);
658 
659  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
660  if (s->rematrixing_flags[bnd]) {
661  bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
662  for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
663  int tmp0 = s->fixed_coeffs[1][i];
664  s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
665  s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
666  }
667  }
668  }
669 }
670 
671 /**
672  * Inverse MDCT Transform.
673  * Convert frequency domain coefficients to time-domain audio samples.
674  * reference: Section 7.9.4 Transformation Equations
675  */
676 static inline void do_imdct(AC3DecodeContext *s, int channels)
677 {
678  int ch;
679 
680  for (ch = 1; ch <= channels; ch++) {
681  if (s->block_switch[ch]) {
682  int i;
683  FFTSample *x = s->tmp_output + 128;
684  for (i = 0; i < 128; i++)
685  x[i] = s->transform_coeffs[ch][2 * i];
686  s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
687 #if USE_FIXED
688  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
689  s->tmp_output, s->window, 128, 8);
690 #else
691  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
692  s->tmp_output, s->window, 128);
693 #endif
694  for (i = 0; i < 128; i++)
695  x[i] = s->transform_coeffs[ch][2 * i + 1];
696  s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
697  } else {
699 #if USE_FIXED
700  s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
701  s->tmp_output, s->window, 128, 8);
702 #else
703  s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
704  s->tmp_output, s->window, 128);
705 #endif
706  memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
707  }
708  }
709 }
710 
711 /**
712  * Upmix delay samples from stereo to original channel layout.
713  */
715 {
716  int channel_data_size = sizeof(s->delay[0]);
717  switch (s->channel_mode) {
718  case AC3_CHMODE_DUALMONO:
719  case AC3_CHMODE_STEREO:
720  /* upmix mono to stereo */
721  memcpy(s->delay[1], s->delay[0], channel_data_size);
722  break;
723  case AC3_CHMODE_2F2R:
724  memset(s->delay[3], 0, channel_data_size);
725  case AC3_CHMODE_2F1R:
726  memset(s->delay[2], 0, channel_data_size);
727  break;
728  case AC3_CHMODE_3F2R:
729  memset(s->delay[4], 0, channel_data_size);
730  case AC3_CHMODE_3F1R:
731  memset(s->delay[3], 0, channel_data_size);
732  case AC3_CHMODE_3F:
733  memcpy(s->delay[2], s->delay[1], channel_data_size);
734  memset(s->delay[1], 0, channel_data_size);
735  break;
736  }
737 }
738 
739 /**
740  * Decode band structure for coupling, spectral extension, or enhanced coupling.
741  * The band structure defines how many subbands are in each band. For each
742  * subband in the range, 1 means it is combined with the previous band, and 0
743  * means that it starts a new band.
744  *
745  * @param[in] gbc bit reader context
746  * @param[in] blk block number
747  * @param[in] eac3 flag to indicate E-AC-3
748  * @param[in] ecpl flag to indicate enhanced coupling
749  * @param[in] start_subband subband number for start of range
750  * @param[in] end_subband subband number for end of range
751  * @param[in] default_band_struct default band structure table
752  * @param[out] num_bands number of bands (optionally NULL)
753  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
754  */
755 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
756  int ecpl, int start_subband, int end_subband,
757  const uint8_t *default_band_struct,
758  int *num_bands, uint8_t *band_sizes)
759 {
760  int subbnd, bnd, n_subbands, n_bands=0;
761  uint8_t bnd_sz[22];
762  uint8_t coded_band_struct[22];
763  const uint8_t *band_struct;
764 
765  n_subbands = end_subband - start_subband;
766 
767  /* decode band structure from bitstream or use default */
768  if (!eac3 || get_bits1(gbc)) {
769  for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
770  coded_band_struct[subbnd] = get_bits1(gbc);
771  }
772  band_struct = coded_band_struct;
773  } else if (!blk) {
774  band_struct = &default_band_struct[start_subband+1];
775  } else {
776  /* no change in band structure */
777  return;
778  }
779 
780  /* calculate number of bands and band sizes based on band structure.
781  note that the first 4 subbands in enhanced coupling span only 6 bins
782  instead of 12. */
783  if (num_bands || band_sizes ) {
784  n_bands = n_subbands;
785  bnd_sz[0] = ecpl ? 6 : 12;
786  for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
787  int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
788  if (band_struct[subbnd - 1]) {
789  n_bands--;
790  bnd_sz[bnd] += subbnd_size;
791  } else {
792  bnd_sz[++bnd] = subbnd_size;
793  }
794  }
795  }
796 
797  /* set optional output params */
798  if (num_bands)
799  *num_bands = n_bands;
800  if (band_sizes)
801  memcpy(band_sizes, bnd_sz, n_bands);
802 }
803 
804 /**
805  * Decode a single audio block from the AC-3 bitstream.
806  */
808 {
809  int fbw_channels = s->fbw_channels;
810  int channel_mode = s->channel_mode;
811  int i, bnd, seg, ch;
812  int different_transforms;
813  int downmix_output;
814  int cpl_in_use;
815  GetBitContext *gbc = &s->gbc;
816  uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
817 
818  /* block switch flags */
819  different_transforms = 0;
820  if (s->block_switch_syntax) {
821  for (ch = 1; ch <= fbw_channels; ch++) {
822  s->block_switch[ch] = get_bits1(gbc);
823  if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
824  different_transforms = 1;
825  }
826  }
827 
828  /* dithering flags */
829  if (s->dither_flag_syntax) {
830  for (ch = 1; ch <= fbw_channels; ch++) {
831  s->dither_flag[ch] = get_bits1(gbc);
832  }
833  }
834 
835  /* dynamic range */
836  i = !s->channel_mode;
837  do {
838  if (get_bits1(gbc)) {
839  /* Allow asymmetric application of DRC when drc_scale > 1.
840  Amplification of quiet sounds is enhanced */
841  int range_bits = get_bits(gbc, 8);
842  INTFLOAT range = AC3_RANGE(range_bits);
843  if (range_bits <= 127 || s->drc_scale <= 1.0)
844  s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
845  else
846  s->dynamic_range[i] = range;
847  } else if (blk == 0) {
849  }
850  } while (i--);
851 
852  /* spectral extension strategy */
853  if (s->eac3 && (!blk || get_bits1(gbc))) {
854  s->spx_in_use = get_bits1(gbc);
855  if (s->spx_in_use) {
856  int dst_start_freq, dst_end_freq, src_start_freq,
857  start_subband, end_subband;
858 
859  /* determine which channels use spx */
860  if (s->channel_mode == AC3_CHMODE_MONO) {
861  s->channel_uses_spx[1] = 1;
862  } else {
863  for (ch = 1; ch <= fbw_channels; ch++)
864  s->channel_uses_spx[ch] = get_bits1(gbc);
865  }
866 
867  /* get the frequency bins of the spx copy region and the spx start
868  and end subbands */
869  dst_start_freq = get_bits(gbc, 2);
870  start_subband = get_bits(gbc, 3) + 2;
871  if (start_subband > 7)
872  start_subband += start_subband - 7;
873  end_subband = get_bits(gbc, 3) + 5;
874 #if USE_FIXED
875  s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
876 #endif
877  if (end_subband > 7)
878  end_subband += end_subband - 7;
879  dst_start_freq = dst_start_freq * 12 + 25;
880  src_start_freq = start_subband * 12 + 25;
881  dst_end_freq = end_subband * 12 + 25;
882 
883  /* check validity of spx ranges */
884  if (start_subband >= end_subband) {
885  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
886  "range (%d >= %d)\n", start_subband, end_subband);
887  return AVERROR_INVALIDDATA;
888  }
889  if (dst_start_freq >= src_start_freq) {
890  av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
891  "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
892  return AVERROR_INVALIDDATA;
893  }
894 
895  s->spx_dst_start_freq = dst_start_freq;
896  s->spx_src_start_freq = src_start_freq;
897  if (!USE_FIXED)
898  s->spx_dst_end_freq = dst_end_freq;
899 
900  decode_band_structure(gbc, blk, s->eac3, 0,
901  start_subband, end_subband,
903  &s->num_spx_bands,
904  s->spx_band_sizes);
905  }
906  }
907  if (!s->eac3 || !s->spx_in_use) {
908  s->spx_in_use = 0;
909  for (ch = 1; ch <= fbw_channels; ch++) {
910  s->channel_uses_spx[ch] = 0;
911  s->first_spx_coords[ch] = 1;
912  }
913  }
914 
915  /* spectral extension coordinates */
916  if (s->spx_in_use) {
917  for (ch = 1; ch <= fbw_channels; ch++) {
918  if (s->channel_uses_spx[ch]) {
919  if (s->first_spx_coords[ch] || get_bits1(gbc)) {
920  INTFLOAT spx_blend;
921  int bin, master_spx_coord;
922 
923  s->first_spx_coords[ch] = 0;
924  spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
925  master_spx_coord = get_bits(gbc, 2) * 3;
926 
927  bin = s->spx_src_start_freq;
928  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
929  int bandsize;
930  int spx_coord_exp, spx_coord_mant;
931  INTFLOAT nratio, sblend, nblend;
932 #if USE_FIXED
933  int64_t accu;
934  /* calculate blending factors */
935  bandsize = s->spx_band_sizes[bnd];
936  accu = (int64_t)((bin << 23) + (bandsize << 22)) * s->spx_dst_end_freq;
937  nratio = (int)(accu >> 32);
938  nratio -= spx_blend << 18;
939 
940  if (nratio < 0) {
941  nblend = 0;
942  sblend = 0x800000;
943  } else if (nratio > 0x7fffff) {
944  nblend = 14529495; // sqrt(3) in FP.23
945  sblend = 0;
946  } else {
947  nblend = fixed_sqrt(nratio, 23);
948  accu = (int64_t)nblend * 1859775393;
949  nblend = (int)((accu + (1<<29)) >> 30);
950  sblend = fixed_sqrt(0x800000 - nratio, 23);
951  }
952 #else
953  float spx_coord;
954 
955  /* calculate blending factors */
956  bandsize = s->spx_band_sizes[bnd];
957  nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
958  nratio = av_clipf(nratio, 0.0f, 1.0f);
959  nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
960  // to give unity variance
961  sblend = sqrtf(1.0f - nratio);
962 #endif
963  bin += bandsize;
964 
965  /* decode spx coordinates */
966  spx_coord_exp = get_bits(gbc, 4);
967  spx_coord_mant = get_bits(gbc, 2);
968  if (spx_coord_exp == 15) spx_coord_mant <<= 1;
969  else spx_coord_mant += 4;
970  spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
971 
972  /* multiply noise and signal blending factors by spx coordinate */
973 #if USE_FIXED
974  accu = (int64_t)nblend * spx_coord_mant;
975  s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
976  accu = (int64_t)sblend * spx_coord_mant;
977  s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
978 #else
979  spx_coord = spx_coord_mant * (1.0f / (1 << 23));
980  s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
981  s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
982 #endif
983  }
984  }
985  } else {
986  s->first_spx_coords[ch] = 1;
987  }
988  }
989  }
990 
991  /* coupling strategy */
992  if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
993  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
994  if (!s->eac3)
995  s->cpl_in_use[blk] = get_bits1(gbc);
996  if (s->cpl_in_use[blk]) {
997  /* coupling in use */
998  int cpl_start_subband, cpl_end_subband;
999 
1000  if (channel_mode < AC3_CHMODE_STEREO) {
1001  av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
1002  return AVERROR_INVALIDDATA;
1003  }
1004 
1005  /* check for enhanced coupling */
1006  if (s->eac3 && get_bits1(gbc)) {
1007  /* TODO: parse enhanced coupling strategy info */
1008  avpriv_request_sample(s->avctx, "Enhanced coupling");
1009  return AVERROR_PATCHWELCOME;
1010  }
1011 
1012  /* determine which channels are coupled */
1013  if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
1014  s->channel_in_cpl[1] = 1;
1015  s->channel_in_cpl[2] = 1;
1016  } else {
1017  for (ch = 1; ch <= fbw_channels; ch++)
1018  s->channel_in_cpl[ch] = get_bits1(gbc);
1019  }
1020 
1021  /* phase flags in use */
1022  if (channel_mode == AC3_CHMODE_STEREO)
1023  s->phase_flags_in_use = get_bits1(gbc);
1024 
1025  /* coupling frequency range */
1026  cpl_start_subband = get_bits(gbc, 4);
1027  cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1028  get_bits(gbc, 4) + 3;
1029  if (cpl_start_subband >= cpl_end_subband) {
1030  av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1031  cpl_start_subband, cpl_end_subband);
1032  return AVERROR_INVALIDDATA;
1033  }
1034  s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1035  s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1036 
1037  decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1038  cpl_end_subband,
1040  &s->num_cpl_bands, s->cpl_band_sizes);
1041  } else {
1042  /* coupling not in use */
1043  for (ch = 1; ch <= fbw_channels; ch++) {
1044  s->channel_in_cpl[ch] = 0;
1045  s->first_cpl_coords[ch] = 1;
1046  }
1047  s->first_cpl_leak = s->eac3;
1048  s->phase_flags_in_use = 0;
1049  }
1050  } else if (!s->eac3) {
1051  if (!blk) {
1052  av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1053  "be present in block 0\n");
1054  return AVERROR_INVALIDDATA;
1055  } else {
1056  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1057  }
1058  }
1059  cpl_in_use = s->cpl_in_use[blk];
1060 
1061  /* coupling coordinates */
1062  if (cpl_in_use) {
1063  int cpl_coords_exist = 0;
1064 
1065  for (ch = 1; ch <= fbw_channels; ch++) {
1066  if (s->channel_in_cpl[ch]) {
1067  if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1068  int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1069  s->first_cpl_coords[ch] = 0;
1070  cpl_coords_exist = 1;
1071  master_cpl_coord = 3 * get_bits(gbc, 2);
1072  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1073  cpl_coord_exp = get_bits(gbc, 4);
1074  cpl_coord_mant = get_bits(gbc, 4);
1075  if (cpl_coord_exp == 15)
1076  s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1077  else
1078  s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1079  s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1080  }
1081  } else if (!blk) {
1082  av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1083  "be present in block 0\n");
1084  return AVERROR_INVALIDDATA;
1085  }
1086  } else {
1087  /* channel not in coupling */
1088  s->first_cpl_coords[ch] = 1;
1089  }
1090  }
1091  /* phase flags */
1092  if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1093  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1094  s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1095  }
1096  }
1097  }
1098 
1099  /* stereo rematrixing strategy and band structure */
1100  if (channel_mode == AC3_CHMODE_STEREO) {
1101  if ((s->eac3 && !blk) || get_bits1(gbc)) {
1102  s->num_rematrixing_bands = 4;
1103  if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1104  s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1105  } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1106  s->num_rematrixing_bands--;
1107  }
1108  for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1109  s->rematrixing_flags[bnd] = get_bits1(gbc);
1110  } else if (!blk) {
1111  av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1112  "new rematrixing strategy not present in block 0\n");
1113  s->num_rematrixing_bands = 0;
1114  }
1115  }
1116 
1117  /* exponent strategies for each channel */
1118  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1119  if (!s->eac3)
1120  s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1121  if (s->exp_strategy[blk][ch] != EXP_REUSE)
1122  bit_alloc_stages[ch] = 3;
1123  }
1124 
1125  /* channel bandwidth */
1126  for (ch = 1; ch <= fbw_channels; ch++) {
1127  s->start_freq[ch] = 0;
1128  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1129  int group_size;
1130  int prev = s->end_freq[ch];
1131  if (s->channel_in_cpl[ch])
1132  s->end_freq[ch] = s->start_freq[CPL_CH];
1133  else if (s->channel_uses_spx[ch])
1134  s->end_freq[ch] = s->spx_src_start_freq;
1135  else {
1136  int bandwidth_code = get_bits(gbc, 6);
1137  if (bandwidth_code > 60) {
1138  av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1139  return AVERROR_INVALIDDATA;
1140  }
1141  s->end_freq[ch] = bandwidth_code * 3 + 73;
1142  }
1143  group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1144  s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1145  if (blk > 0 && s->end_freq[ch] != prev)
1146  memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1147  }
1148  }
1149  if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1151  (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1152  }
1153 
1154  /* decode exponents for each channel */
1155  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1156  if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1157  s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1158  if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1159  s->num_exp_groups[ch], s->dexps[ch][0],
1160  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1161  av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1162  return AVERROR_INVALIDDATA;
1163  }
1164  if (ch != CPL_CH && ch != s->lfe_ch)
1165  skip_bits(gbc, 2); /* skip gainrng */
1166  }
1167  }
1168 
1169  /* bit allocation information */
1170  if (s->bit_allocation_syntax) {
1171  if (get_bits1(gbc)) {
1177  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1178  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1179  } else if (!blk) {
1180  av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1181  "be present in block 0\n");
1182  return AVERROR_INVALIDDATA;
1183  }
1184  }
1185 
1186  /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1187  if (!s->eac3 || !blk) {
1188  if (s->snr_offset_strategy && get_bits1(gbc)) {
1189  int snr = 0;
1190  int csnr;
1191  csnr = (get_bits(gbc, 6) - 15) << 4;
1192  for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1193  /* snr offset */
1194  if (ch == i || s->snr_offset_strategy == 2)
1195  snr = (csnr + get_bits(gbc, 4)) << 2;
1196  /* run at least last bit allocation stage if snr offset changes */
1197  if (blk && s->snr_offset[ch] != snr) {
1198  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1199  }
1200  s->snr_offset[ch] = snr;
1201 
1202  /* fast gain (normal AC-3 only) */
1203  if (!s->eac3) {
1204  int prev = s->fast_gain[ch];
1205  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1206  /* run last 2 bit allocation stages if fast gain changes */
1207  if (blk && prev != s->fast_gain[ch])
1208  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1209  }
1210  }
1211  } else if (!s->eac3 && !blk) {
1212  av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1213  return AVERROR_INVALIDDATA;
1214  }
1215  }
1216 
1217  /* fast gain (E-AC-3 only) */
1218  if (s->fast_gain_syntax && get_bits1(gbc)) {
1219  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1220  int prev = s->fast_gain[ch];
1221  s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1222  /* run last 2 bit allocation stages if fast gain changes */
1223  if (blk && prev != s->fast_gain[ch])
1224  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1225  }
1226  } else if (s->eac3 && !blk) {
1227  for (ch = !cpl_in_use; ch <= s->channels; ch++)
1228  s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1229  }
1230 
1231  /* E-AC-3 to AC-3 converter SNR offset */
1232  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1233  skip_bits(gbc, 10); // skip converter snr offset
1234  }
1235 
1236  /* coupling leak information */
1237  if (cpl_in_use) {
1238  if (s->first_cpl_leak || get_bits1(gbc)) {
1239  int fl = get_bits(gbc, 3);
1240  int sl = get_bits(gbc, 3);
1241  /* run last 2 bit allocation stages for coupling channel if
1242  coupling leak changes */
1243  if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1244  sl != s->bit_alloc_params.cpl_slow_leak)) {
1245  bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1246  }
1249  } else if (!s->eac3 && !blk) {
1250  av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1251  "be present in block 0\n");
1252  return AVERROR_INVALIDDATA;
1253  }
1254  s->first_cpl_leak = 0;
1255  }
1256 
1257  /* delta bit allocation information */
1258  if (s->dba_syntax && get_bits1(gbc)) {
1259  /* delta bit allocation exists (strategy) */
1260  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1261  s->dba_mode[ch] = get_bits(gbc, 2);
1262  if (s->dba_mode[ch] == DBA_RESERVED) {
1263  av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1264  return AVERROR_INVALIDDATA;
1265  }
1266  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1267  }
1268  /* channel delta offset, len and bit allocation */
1269  for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1270  if (s->dba_mode[ch] == DBA_NEW) {
1271  s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1272  for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1273  s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1274  s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1275  s->dba_values[ch][seg] = get_bits(gbc, 3);
1276  }
1277  /* run last 2 bit allocation stages if new dba values */
1278  bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1279  }
1280  }
1281  } else if (blk == 0) {
1282  for (ch = 0; ch <= s->channels; ch++) {
1283  s->dba_mode[ch] = DBA_NONE;
1284  }
1285  }
1286 
1287  /* Bit allocation */
1288  for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1289  if (bit_alloc_stages[ch] > 2) {
1290  /* Exponent mapping into PSD and PSD integration */
1292  s->start_freq[ch], s->end_freq[ch],
1293  s->psd[ch], s->band_psd[ch]);
1294  }
1295  if (bit_alloc_stages[ch] > 1) {
1296  /* Compute excitation function, Compute masking curve, and
1297  Apply delta bit allocation */
1299  s->start_freq[ch], s->end_freq[ch],
1300  s->fast_gain[ch], (ch == s->lfe_ch),
1301  s->dba_mode[ch], s->dba_nsegs[ch],
1302  s->dba_offsets[ch], s->dba_lengths[ch],
1303  s->dba_values[ch], s->mask[ch])) {
1304  av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1305  return AVERROR_INVALIDDATA;
1306  }
1307  }
1308  if (bit_alloc_stages[ch] > 0) {
1309  /* Compute bit allocation */
1310  const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1312  s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1313  s->start_freq[ch], s->end_freq[ch],
1314  s->snr_offset[ch],
1316  bap_tab, s->bap[ch]);
1317  }
1318  }
1319 
1320  /* unused dummy data */
1321  if (s->skip_syntax && get_bits1(gbc)) {
1322  int skipl = get_bits(gbc, 9);
1323  while (skipl--)
1324  skip_bits(gbc, 8);
1325  }
1326 
1327  /* unpack the transform coefficients
1328  this also uncouples channels if coupling is in use. */
1329  decode_transform_coeffs(s, blk);
1330 
1331  /* TODO: generate enhanced coupling coordinates and uncouple */
1332 
1333  /* recover coefficients if rematrixing is in use */
1334  if (s->channel_mode == AC3_CHMODE_STEREO)
1335  do_rematrixing(s);
1336 
1337  /* apply scaling to coefficients (headroom, dynrng) */
1338  for (ch = 1; ch <= s->channels; ch++) {
1339  int audio_channel = 0;
1340  INTFLOAT gain;
1342  audio_channel = 2-ch;
1343  if (s->heavy_compression && s->compression_exists[audio_channel])
1344  gain = s->heavy_dynamic_range[audio_channel];
1345  else
1346  gain = s->dynamic_range[audio_channel];
1347 
1348 #if USE_FIXED
1349  scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1350 #else
1351  if (s->target_level != 0)
1352  gain = gain * s->level_gain[audio_channel];
1353  gain *= 1.0 / 4194304.0f;
1355  s->fixed_coeffs[ch], gain, 256);
1356 #endif
1357  }
1358 
1359  /* apply spectral extension to high frequency bins */
1360  if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1362  }
1363 
1364  /* downmix and MDCT. order depends on whether block switching is used for
1365  any channel in this block. this is because coefficients for the long
1366  and short transforms cannot be mixed. */
1367  downmix_output = s->channels != s->out_channels &&
1368  !((s->output_mode & AC3_OUTPUT_LFEON) &&
1369  s->fbw_channels == s->out_channels);
1370  if (different_transforms) {
1371  /* the delay samples have already been downmixed, so we upmix the delay
1372  samples in order to reconstruct all channels before downmixing. */
1373  if (s->downmixed) {
1374  s->downmixed = 0;
1375  ac3_upmix_delay(s);
1376  }
1377 
1378  do_imdct(s, s->channels);
1379 
1380  if (downmix_output) {
1381 #if USE_FIXED
1383  s->out_channels, s->fbw_channels, 256);
1384 #else
1385  s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1386  s->out_channels, s->fbw_channels, 256);
1387 #endif
1388  }
1389  } else {
1390  if (downmix_output) {
1391  s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1392  s->out_channels, s->fbw_channels, 256);
1393  }
1394 
1395  if (downmix_output && !s->downmixed) {
1396  s->downmixed = 1;
1397  s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1398  s->out_channels, s->fbw_channels, 128);
1399  }
1400 
1401  do_imdct(s, s->out_channels);
1402  }
1403 
1404  return 0;
1405 }
1406 
1407 /**
1408  * Decode a single AC-3 frame.
1409  */
1410 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1411  int *got_frame_ptr, AVPacket *avpkt)
1412 {
1413  AVFrame *frame = data;
1414  const uint8_t *buf = avpkt->data;
1415  int buf_size = avpkt->size;
1416  AC3DecodeContext *s = avctx->priv_data;
1417  int blk, ch, err, ret;
1418  const uint8_t *channel_map;
1419  const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1420  enum AVMatrixEncoding matrix_encoding;
1421  AVDownmixInfo *downmix_info;
1422 
1423  /* copy input buffer to decoder context to avoid reading past the end
1424  of the buffer, which can be caused by a damaged input stream. */
1425  if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1426  // seems to be byte-swapped AC-3
1427  int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1428  s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1429  (const uint16_t *) buf, cnt);
1430  } else
1431  memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1432  buf = s->input_buffer;
1433  /* initialize the GetBitContext with the start of valid AC-3 Frame */
1434  if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1435  return ret;
1436 
1437  /* parse the syncinfo */
1438  err = parse_frame_header(s);
1439 
1440  if (err) {
1441  switch (err) {
1443  av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1444  return AVERROR_INVALIDDATA;
1446  av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1447  break;
1449  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1450  break;
1452  av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1453  break;
1455  /* skip frame if CRC is ok. otherwise use error concealment. */
1456  /* TODO: add support for substreams and dependent frames */
1458  av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1459  "skipping frame\n");
1460  *got_frame_ptr = 0;
1461  return buf_size;
1462  } else {
1463  av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1464  }
1465  break;
1468  break;
1469  default: // Normal AVERROR do not try to recover.
1470  *got_frame_ptr = 0;
1471  return err;
1472  }
1473  } else {
1474  /* check that reported frame size fits in input buffer */
1475  if (s->frame_size > buf_size) {
1476  av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1478  } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1479  /* check for crc mismatch */
1480  if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1481  s->frame_size - 2)) {
1482  av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1483  if (avctx->err_recognition & AV_EF_EXPLODE)
1484  return AVERROR_INVALIDDATA;
1486  }
1487  }
1488  }
1489 
1490  /* if frame is ok, set audio parameters */
1491  if (!err) {
1492  avctx->sample_rate = s->sample_rate;
1493  avctx->bit_rate = s->bit_rate;
1494  }
1495 
1496  /* channel config */
1497  if (!err || (s->channels && s->out_channels != s->channels)) {
1498  s->out_channels = s->channels;
1499  s->output_mode = s->channel_mode;
1500  if (s->lfe_on)
1502  if (s->channels > 1 &&
1504  s->out_channels = 1;
1506  } else if (s->channels > 2 &&
1508  s->out_channels = 2;
1510  }
1511 
1512  s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1516  /* set downmixing coefficients if needed */
1517  if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1518  s->fbw_channels == s->out_channels)) {
1519  set_downmix_coeffs(s);
1520  }
1521  } else if (!s->channels) {
1522  av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1523  return AVERROR_INVALIDDATA;
1524  }
1525  avctx->channels = s->out_channels;
1527  if (s->output_mode & AC3_OUTPUT_LFEON)
1529 
1530  /* set audio service type based on bitstream mode for AC-3 */
1531  avctx->audio_service_type = s->bitstream_mode;
1532  if (s->bitstream_mode == 0x7 && s->channels > 1)
1534 
1535  /* get output buffer */
1536  frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1537  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1538  return ret;
1539 
1540  /* decode the audio blocks */
1541  channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1542  for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1543  output[ch] = s->output[ch];
1544  s->outptr[ch] = s->output[ch];
1545  }
1546  for (ch = 0; ch < s->channels; ch++) {
1547  if (ch < s->out_channels)
1548  s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1549  }
1550  for (blk = 0; blk < s->num_blocks; blk++) {
1551  if (!err && decode_audio_block(s, blk)) {
1552  av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1553  err = 1;
1554  }
1555  if (err)
1556  for (ch = 0; ch < s->out_channels; ch++)
1557  memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1558  for (ch = 0; ch < s->out_channels; ch++)
1559  output[ch] = s->outptr[channel_map[ch]];
1560  for (ch = 0; ch < s->out_channels; ch++) {
1561  if (!ch || channel_map[ch])
1562  s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1563  }
1564  }
1565 
1567 
1568  /* keep last block for error concealment in next frame */
1569  for (ch = 0; ch < s->out_channels; ch++)
1570  memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1571 
1572  /*
1573  * AVMatrixEncoding
1574  *
1575  * Check whether the input layout is compatible, and make sure we're not
1576  * downmixing (else the matrix encoding is no longer applicable).
1577  */
1578  matrix_encoding = AV_MATRIX_ENCODING_NONE;
1579  if (s->channel_mode == AC3_CHMODE_STEREO &&
1580  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1582  matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1584  matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1585  } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1586  s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1587  switch (s->dolby_surround_ex_mode) {
1588  case AC3_DSUREXMOD_ON: // EX or PLIIx
1589  matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1590  break;
1591  case AC3_DSUREXMOD_PLIIZ:
1592  matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1593  break;
1594  default: // not indicated or off
1595  break;
1596  }
1597  }
1598  if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1599  return ret;
1600 
1601  /* AVDownmixInfo */
1602  if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1603  switch (s->preferred_downmix) {
1604  case AC3_DMIXMOD_LTRT:
1606  break;
1607  case AC3_DMIXMOD_LORO:
1609  break;
1610  case AC3_DMIXMOD_DPLII:
1612  break;
1613  default:
1615  break;
1616  }
1617  downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1618  downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1619  downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1621  if (s->lfe_mix_level_exists)
1622  downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1623  else
1624  downmix_info->lfe_mix_level = 0.0; // -inf dB
1625  } else
1626  return AVERROR(ENOMEM);
1627 
1628  *got_frame_ptr = 1;
1629 
1630  return FFMIN(buf_size, s->frame_size);
1631 }
1632 
1633 /**
1634  * Uninitialize the AC-3 decoder.
1635  */
1637 {
1638  AC3DecodeContext *s = avctx->priv_data;
1639  ff_mdct_end(&s->imdct_512);
1640  ff_mdct_end(&s->imdct_256);
1641  av_freep(&s->fdsp);
1642 
1643  return 0;
1644 }
1645 
1646 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1647 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)