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