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