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