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