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