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