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