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