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