Add needed include, make it compile without -D_BSD_SOURCE.
[libav.git] / libavcodec / ac3dec.c
CommitLineData
0ec2cc35
JR
1/*
2 * AC-3 Audio Decoder
032732d4
JR
3 * This code is developed as part of Google Summer of Code 2006 Program.
4 *
0ec2cc35 5 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
36266421 6 * Copyright (c) 2007 Justin Ruggles
032732d4 7 *
36266421 8 * Portions of this code are derived from liba52
032732d4 9 * http://liba52.sourceforge.net
36266421
JR
10 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
11 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
032732d4 12 *
0ec2cc35 13 * This file is part of FFmpeg.
2aa2c5c4 14 *
0ec2cc35 15 * FFmpeg is free software; you can redistribute it and/or
9d109601 16 * modify it under the terms of the GNU General Public
2aa2c5c4
JR
17 * License as published by the Free Software Foundation; either
18 * version 2 of the License, or (at your option) any later version.
19 *
0ec2cc35 20 * FFmpeg is distributed in the hope that it will be useful,
2aa2c5c4
JR
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
283614b5 23 * General Public License for more details.
2aa2c5c4 24 *
283614b5 25 * You should have received a copy of the GNU General Public
0ec2cc35 26 * License along with FFmpeg; if not, write to the Free Software
2aa2c5c4
JR
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 */
29
30#include <stdio.h>
31#include <stddef.h>
32#include <math.h>
2aa2c5c4
JR
33#include <string.h>
34
245976da
DB
35#include "libavutil/crc.h"
36#include "libavutil/random.h"
e6bca37c 37#include "avcodec.h"
9fc1ab72 38#include "ac3_parser.h"
2aa2c5c4
JR
39#include "bitstream.h"
40#include "dsputil.h"
58ce349f 41#include "ac3dec.h"
227322b8 42#include "ac3dec_data.h"
98a27a8a 43
c33a1967
JR
44/** Maximum possible frame size when the specification limit is ignored */
45#define AC3_MAX_FRAME_SIZE 21695
46
7417120b
JR
47/**
48 * table for ungrouping 3 values in 7 bits.
49 * used for exponents and bap=2 mantissas
50 */
51static uint8_t ungroup_3_in_7_bits_tab[128][3];
967d397a 52
967d397a 53
5aefe3eb 54/** tables for ungrouping mantissas */
a4de6dd2
JR
55static int b1_mantissas[32][3];
56static int b2_mantissas[128][3];
57static int b3_mantissas[8];
58static int b4_mantissas[128][2];
59static int b5_mantissas[16];
967d397a 60
5aefe3eb
JR
61/**
62 * Quantization table: levels for symmetric. bits for asymmetric.
63 * reference: Table 7.18 Mapping of bap to Quantizer
64 */
e2270b4e 65static const uint8_t quantization_tab[16] = {
5aefe3eb
JR
66 0, 3, 5, 7, 11, 15,
67 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
68};
967d397a 69
3357ff33 70/** dynamic range table. converts codes to scale factors. */
e2270b4e 71static float dynamic_range_tab[256];
3357ff33 72
5066f515 73/** Adjustments in dB gain */
caf0fbc8
JR
74#define LEVEL_PLUS_3DB 1.4142135623730950
75#define LEVEL_PLUS_1POINT5DB 1.1892071150027209
76#define LEVEL_MINUS_1POINT5DB 0.8408964152537145
967d397a
JR
77#define LEVEL_MINUS_3DB 0.7071067811865476
78#define LEVEL_MINUS_4POINT5DB 0.5946035575013605
79#define LEVEL_MINUS_6DB 0.5000000000000000
3bbb0bf8 80#define LEVEL_MINUS_9DB 0.3535533905932738
967d397a 81#define LEVEL_ZERO 0.0000000000000000
3bbb0bf8
JR
82#define LEVEL_ONE 1.0000000000000000
83
caf0fbc8
JR
84static const float gain_levels[9] = {
85 LEVEL_PLUS_3DB,
86 LEVEL_PLUS_1POINT5DB,
3bbb0bf8 87 LEVEL_ONE,
caf0fbc8 88 LEVEL_MINUS_1POINT5DB,
3bbb0bf8
JR
89 LEVEL_MINUS_3DB,
90 LEVEL_MINUS_4POINT5DB,
91 LEVEL_MINUS_6DB,
caf0fbc8 92 LEVEL_ZERO,
3bbb0bf8
JR
93 LEVEL_MINUS_9DB
94};
967d397a 95
3bbb0bf8 96/**
30f71adc
JR
97 * Table for center mix levels
98 * reference: Section 5.4.2.4 cmixlev
99 */
100static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
101
102/**
103 * Table for surround mix levels
104 * reference: Section 5.4.2.5 surmixlev
105 */
106static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
107
108/**
3bbb0bf8
JR
109 * Table for default stereo downmixing coefficients
110 * reference: Section 7.8.2 Downmixing Into Two Channels
111 */
112static const uint8_t ac3_default_coeffs[8][5][2] = {
caf0fbc8
JR
113 { { 2, 7 }, { 7, 2 }, },
114 { { 4, 4 }, },
115 { { 2, 7 }, { 7, 2 }, },
116 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
117 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
118 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
119 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
120 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
3bbb0bf8 121};
967d397a 122
2fbbd087 123/**
5066f515
JR
124 * Symmetrical Dequantization
125 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
126 * Tables 7.19 to 7.23
127 */
a4de6dd2 128static inline int
5aefe3eb 129symmetric_dequant(int code, int levels)
98a27a8a 130{
a4de6dd2 131 return ((code - (levels >> 1)) << 24) / levels;
98a27a8a
JR
132}
133
c7cfc48f
JR
134/*
135 * Initialize tables at runtime.
136 */
98a6fff9 137static av_cold void ac3_tables_init(void)
00585845 138{
4415076f 139 int i;
98a27a8a 140
7417120b
JR
141 /* generate table for ungrouping 3 values in 7 bits
142 reference: Section 7.1.3 Exponent Decoding */
143 for(i=0; i<128; i++) {
144 ungroup_3_in_7_bits_tab[i][0] = i / 25;
145 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
146 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
147 }
148
5aefe3eb
JR
149 /* generate grouped mantissa tables
150 reference: Section 7.3.5 Ungrouping of Mantissas */
151 for(i=0; i<32; i++) {
152 /* bap=1 mantissas */
602116df
JR
153 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
154 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
155 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
5aefe3eb
JR
156 }
157 for(i=0; i<128; i++) {
158 /* bap=2 mantissas */
7417120b
JR
159 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
160 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
161 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
5aefe3eb
JR
162
163 /* bap=4 mantissas */
164 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
165 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
166 }
167 /* generate ungrouped mantissa tables
168 reference: Tables 7.21 and 7.23 */
169 for(i=0; i<7; i++) {
170 /* bap=3 mantissas */
171 b3_mantissas[i] = symmetric_dequant(i, 7);
172 }
173 for(i=0; i<15; i++) {
174 /* bap=5 mantissas */
175 b5_mantissas[i] = symmetric_dequant(i, 15);
176 }
c7cfc48f 177
3357ff33
JR
178 /* generate dynamic range table
179 reference: Section 7.7.1 Dynamic Range Control */
180 for(i=0; i<256; i++) {
181 int v = (i >> 5) - ((i >> 7) << 3) - 5;
e2270b4e 182 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
3357ff33 183 }
00585845
JR
184}
185
1b293437 186
5066f515
JR
187/**
188 * AVCodec initialization
189 */
98a6fff9 190static av_cold int ac3_decode_init(AVCodecContext *avctx)
1b293437 191{
d802d7ca
JR
192 AC3DecodeContext *s = avctx->priv_data;
193 s->avctx = avctx;
1b293437 194
cc2a8443 195 ac3_common_init();
98a27a8a 196 ac3_tables_init();
d802d7ca
JR
197 ff_mdct_init(&s->imdct_256, 8, 1);
198 ff_mdct_init(&s->imdct_512, 9, 1);
3ed546fe 199 ff_kbd_window_init(s->window, 5.0, 256);
d802d7ca
JR
200 dsputil_init(&s->dsp, avctx);
201 av_init_random(0, &s->dith_state);
2aa2c5c4 202
5066f515 203 /* set bias values for float to int16 conversion */
72745cff 204 if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
d802d7ca
JR
205 s->add_bias = 385.0f;
206 s->mul_bias = 1.0f;
4e092320 207 } else {
d802d7ca
JR
208 s->add_bias = 0.0f;
209 s->mul_bias = 32767.0f;
4e092320
JR
210 }
211
95283c17
JR
212 /* allow downmixing to stereo or mono */
213 if (avctx->channels > 0 && avctx->request_channels > 0 &&
214 avctx->request_channels < avctx->channels &&
215 avctx->request_channels <= 2) {
216 avctx->channels = avctx->request_channels;
217 }
38dae9c3 218 s->downmixed = 1;
95283c17 219
509fdb0b
JR
220 /* allocate context input buffer */
221 if (avctx->error_resilience >= FF_ER_CAREFUL) {
222 s->input_buffer = av_mallocz(AC3_MAX_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
223 if (!s->input_buffer)
224 return AVERROR_NOMEM;
225 }
226
fd76c37f 227 avctx->sample_fmt = SAMPLE_FMT_S16;
1b293437 228 return 0;
2aa2c5c4
JR
229}
230
9fc1ab72 231/**
5066f515 232 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
c7cfc48f 233 * GetBitContext within AC3DecodeContext must point to
14b70628 234 * the start of the synchronized AC-3 bitstream.
c7cfc48f 235 */
d802d7ca 236static int ac3_parse_header(AC3DecodeContext *s)
2aa2c5c4 237{
4397d95c
JR
238 GetBitContext *gbc = &s->gbc;
239 int i;
240
241 /* read the rest of the bsi. read twice for dual mono mode. */
242 i = !(s->channel_mode);
243 do {
244 skip_bits(gbc, 5); // skip dialog normalization
245 if (get_bits1(gbc))
246 skip_bits(gbc, 8); //skip compression
247 if (get_bits1(gbc))
248 skip_bits(gbc, 8); //skip language code
249 if (get_bits1(gbc))
250 skip_bits(gbc, 7); //skip audio production information
251 } while (i--);
252
253 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
254
255 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
256 TODO: read & use the xbsi1 downmix levels */
257 if (get_bits1(gbc))
258 skip_bits(gbc, 14); //skip timecode1 / xbsi1
259 if (get_bits1(gbc))
260 skip_bits(gbc, 14); //skip timecode2 / xbsi2
261
262 /* skip additional bitstream info */
263 if (get_bits1(gbc)) {
264 i = get_bits(gbc, 6);
265 do {
266 skip_bits(gbc, 8);
267 } while(i--);
268 }
269
270 return 0;
271}
272
273/**
14b70628 274 * Common function to parse AC-3 or E-AC-3 frame header
4397d95c
JR
275 */
276static int parse_frame_header(AC3DecodeContext *s)
277{
9fc1ab72 278 AC3HeaderInfo hdr;
4397d95c 279 int err;
9fc1ab72 280
ba7f712c 281 err = ff_ac3_parse_header(&s->gbc, &hdr);
9fc1ab72
JR
282 if(err)
283 return err;
284
285 /* get decoding parameters from header info */
d802d7ca
JR
286 s->bit_alloc_params.sr_code = hdr.sr_code;
287 s->channel_mode = hdr.channel_mode;
1b70d88b 288 s->lfe_on = hdr.lfe_on;
d802d7ca 289 s->bit_alloc_params.sr_shift = hdr.sr_shift;
866181e5 290 s->sample_rate = hdr.sample_rate;
d802d7ca
JR
291 s->bit_rate = hdr.bit_rate;
292 s->channels = hdr.channels;
293 s->fbw_channels = s->channels - s->lfe_on;
294 s->lfe_ch = s->fbw_channels + 1;
295 s->frame_size = hdr.frame_size;
55736cfb
BW
296 s->center_mix_level = hdr.center_mix_level;
297 s->surround_mix_level = hdr.surround_mix_level;
6730e9f3 298 s->num_blocks = hdr.num_blocks;
be5f17b9 299 s->frame_type = hdr.frame_type;
3596aa6f 300 s->substreamid = hdr.substreamid;
7bfd22f2 301
6e74513a
JR
302 if(s->lfe_on) {
303 s->start_freq[s->lfe_ch] = 0;
304 s->end_freq[s->lfe_ch] = 7;
305 s->num_exp_groups[s->lfe_ch] = 2;
306 s->channel_in_cpl[s->lfe_ch] = 0;
307 }
308
55aff0d9
JR
309 if(hdr.bitstream_id > 10)
310 return AC3_PARSE_ERROR_BSID;
311
4397d95c 312 return ac3_parse_header(s);
f0b3a7ba
JR
313}
314
315/**
316 * Set stereo downmixing coefficients based on frame header info.
317 * reference: Section 7.8.2 Downmixing Into Two Channels
318 */
319static void set_downmix_coeffs(AC3DecodeContext *s)
320{
321 int i;
30f71adc
JR
322 float cmix = gain_levels[center_levels[s->center_mix_level]];
323 float smix = gain_levels[surround_levels[s->surround_mix_level]];
f0b3a7ba 324
d802d7ca
JR
325 for(i=0; i<s->fbw_channels; i++) {
326 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
327 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
3bbb0bf8 328 }
d802d7ca 329 if(s->channel_mode > 1 && s->channel_mode & 1) {
f0b3a7ba 330 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
3bbb0bf8 331 }
d802d7ca
JR
332 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
333 int nf = s->channel_mode - 2;
f0b3a7ba 334 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
3bbb0bf8 335 }
d802d7ca
JR
336 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
337 int nf = s->channel_mode - 4;
f0b3a7ba 338 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
3bbb0bf8 339 }
9d10e6e6 340
d8870f12
JR
341 /* calculate adjustment needed for each channel to avoid clipping */
342 s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
9d10e6e6 343 for(i=0; i<s->fbw_channels; i++) {
d8870f12
JR
344 s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
345 s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
9d10e6e6 346 }
d8870f12
JR
347 s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
348 s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
2aa2c5c4
JR
349}
350
3bb004fc 351/**
5066f515
JR
352 * Decode the grouped exponents according to exponent strategy.
353 * reference: Section 7.1.3 Exponent Decoding
2aa2c5c4 354 */
23c8cb89 355static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
bc8edb7e 356 uint8_t absexp, int8_t *dexps)
2aa2c5c4 357{
e2270b4e 358 int i, j, grp, group_size;
4415076f
JR
359 int dexp[256];
360 int expacc, prevexp;
361
362 /* unpack groups */
e2270b4e 363 group_size = exp_strategy + (exp_strategy == EXP_D45);
4415076f 364 for(grp=0,i=0; grp<ngrps; grp++) {
23c8cb89 365 expacc = get_bits(gbc, 7);
7417120b
JR
366 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
367 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
368 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
4415076f 369 }
2aa2c5c4 370
4415076f
JR
371 /* convert to absolute exps and expand groups */
372 prevexp = absexp;
373 for(i=0; i<ngrps*3; i++) {
374 prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
e2270b4e
JR
375 for(j=0; j<group_size; j++) {
376 dexps[(i*group_size)+j] = prevexp;
1b293437 377 }
2aa2c5c4 378 }
2aa2c5c4
JR
379}
380
d7dc7ad0 381/**
5066f515 382 * Generate transform coefficients for each coupled channel in the coupling
d7dc7ad0
JR
383 * range using the coupling coefficients and coupling coordinates.
384 * reference: Section 7.4.3 Coupling Coordinate Format
385 */
5e3e4075 386static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
d7dc7ad0
JR
387{
388 int i, j, ch, bnd, subbnd;
389
390 subbnd = -1;
d802d7ca
JR
391 i = s->start_freq[CPL_CH];
392 for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
d7dc7ad0
JR
393 do {
394 subbnd++;
395 for(j=0; j<12; j++) {
d802d7ca 396 for(ch=1; ch<=s->fbw_channels; ch++) {
b02fbf75 397 if(s->channel_in_cpl[ch]) {
a4de6dd2 398 s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
b02fbf75 399 if (ch == 2 && s->phase_flags[bnd])
a4de6dd2 400 s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
b02fbf75 401 }
d7dc7ad0
JR
402 }
403 i++;
404 }
d802d7ca 405 } while(s->cpl_band_struct[subbnd]);
d7dc7ad0
JR
406 }
407}
408
5066f515
JR
409/**
410 * Grouped mantissas for 3-level 5-level and 11-level quantization
411 */
412typedef struct {
a4de6dd2
JR
413 int b1_mant[3];
414 int b2_mant[3];
415 int b4_mant[2];
5aefe3eb
JR
416 int b1ptr;
417 int b2ptr;
418 int b4ptr;
486637af
JR
419} mant_groups;
420
5066f515
JR
421/**
422 * Get the transform coefficients for a particular channel
423 * reference: Section 7.3 Quantization and Decoding of Mantissas
424 */
ff5d419e 425static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
1b293437 426{
d802d7ca 427 GetBitContext *gbc = &s->gbc;
60f07fad 428 int i, gcode, tbap, start, end;
2fbbd087
JR
429 uint8_t *exps;
430 uint8_t *bap;
a4de6dd2 431 int *coeffs;
2fbbd087 432
d802d7ca
JR
433 exps = s->dexps[ch_index];
434 bap = s->bap[ch_index];
a4de6dd2 435 coeffs = s->fixed_coeffs[ch_index];
d802d7ca
JR
436 start = s->start_freq[ch_index];
437 end = s->end_freq[ch_index];
1b293437 438
285bf28c 439 for (i = start; i < end; i++) {
98a27a8a
JR
440 tbap = bap[i];
441 switch (tbap) {
1b293437 442 case 0:
7645da91 443 coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 0x400000;
d63f6fea 444 break;
1b293437
JR
445
446 case 1:
5aefe3eb 447 if(m->b1ptr > 2) {
23c8cb89 448 gcode = get_bits(gbc, 5);
5aefe3eb
JR
449 m->b1_mant[0] = b1_mantissas[gcode][0];
450 m->b1_mant[1] = b1_mantissas[gcode][1];
451 m->b1_mant[2] = b1_mantissas[gcode][2];
452 m->b1ptr = 0;
1b293437 453 }
5aefe3eb 454 coeffs[i] = m->b1_mant[m->b1ptr++];
d63f6fea 455 break;
1b293437
JR
456
457 case 2:
5aefe3eb 458 if(m->b2ptr > 2) {
23c8cb89 459 gcode = get_bits(gbc, 7);
5aefe3eb
JR
460 m->b2_mant[0] = b2_mantissas[gcode][0];
461 m->b2_mant[1] = b2_mantissas[gcode][1];
462 m->b2_mant[2] = b2_mantissas[gcode][2];
463 m->b2ptr = 0;
1b293437 464 }
5aefe3eb 465 coeffs[i] = m->b2_mant[m->b2ptr++];
d63f6fea 466 break;
1b293437
JR
467
468 case 3:
23c8cb89 469 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
d63f6fea 470 break;
1b293437
JR
471
472 case 4:
5aefe3eb 473 if(m->b4ptr > 1) {
23c8cb89 474 gcode = get_bits(gbc, 7);
5aefe3eb
JR
475 m->b4_mant[0] = b4_mantissas[gcode][0];
476 m->b4_mant[1] = b4_mantissas[gcode][1];
477 m->b4ptr = 0;
1b293437 478 }
5aefe3eb 479 coeffs[i] = m->b4_mant[m->b4ptr++];
d63f6fea 480 break;
1b293437
JR
481
482 case 5:
23c8cb89 483 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
d63f6fea 484 break;
1b293437 485
a4de6dd2 486 default: {
5066f515 487 /* asymmetric dequantization */
a4de6dd2
JR
488 int qlevel = quantization_tab[tbap];
489 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
d63f6fea 490 break;
a4de6dd2 491 }
1b293437 492 }
a4de6dd2 493 coeffs[i] >>= exps[i];
1b293437 494 }
1b293437
JR
495}
496
60f07fad 497/**
5066f515 498 * Remove random dithering from coefficients with zero-bit mantissas
60f07fad
JR
499 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
500 */
d802d7ca 501static void remove_dithering(AC3DecodeContext *s) {
60f07fad
JR
502 int ch, i;
503 int end=0;
a4de6dd2 504 int *coeffs;
60f07fad
JR
505 uint8_t *bap;
506
d802d7ca
JR
507 for(ch=1; ch<=s->fbw_channels; ch++) {
508 if(!s->dither_flag[ch]) {
a4de6dd2 509 coeffs = s->fixed_coeffs[ch];
d802d7ca
JR
510 bap = s->bap[ch];
511 if(s->channel_in_cpl[ch])
512 end = s->start_freq[CPL_CH];
60f07fad 513 else
d802d7ca 514 end = s->end_freq[ch];
60f07fad 515 for(i=0; i<end; i++) {
12eaa3b7 516 if(!bap[i])
a4de6dd2 517 coeffs[i] = 0;
60f07fad 518 }
d802d7ca
JR
519 if(s->channel_in_cpl[ch]) {
520 bap = s->bap[CPL_CH];
521 for(; i<s->end_freq[CPL_CH]; i++) {
12eaa3b7 522 if(!bap[i])
a4de6dd2 523 coeffs[i] = 0;
60f07fad
JR
524 }
525 }
526 }
527 }
528}
529
5066f515
JR
530/**
531 * Get the transform coefficients.
c7cfc48f 532 */
ff5d419e 533static void get_transform_coeffs(AC3DecodeContext *s)
1b293437 534{
7b4076a7 535 int ch, end;
1b293437 536 int got_cplchan = 0;
486637af
JR
537 mant_groups m;
538
5aefe3eb 539 m.b1ptr = m.b2ptr = m.b4ptr = 3;
1b293437 540
d802d7ca 541 for (ch = 1; ch <= s->channels; ch++) {
5066f515 542 /* transform coefficients for full-bandwidth channel */
ff5d419e 543 get_transform_coeffs_ch(s, ch, &m);
5066f515
JR
544 /* tranform coefficients for coupling channel come right after the
545 coefficients for the first coupled channel*/
d802d7ca 546 if (s->channel_in_cpl[ch]) {
486637af 547 if (!got_cplchan) {
ff5d419e 548 get_transform_coeffs_ch(s, CPL_CH, &m);
5e3e4075 549 calc_transform_coeffs_cpl(s);
486637af
JR
550 got_cplchan = 1;
551 }
d802d7ca 552 end = s->end_freq[CPL_CH];
eaf84d97 553 } else {
d802d7ca 554 end = s->end_freq[ch];
eaf84d97 555 }
486637af 556 do
bd98e9e2 557 s->fixed_coeffs[ch][end] = 0;
486637af
JR
558 while(++end < 256);
559 }
1b293437 560
60f07fad 561 /* if any channel doesn't use dithering, zero appropriate coefficients */
d802d7ca
JR
562 if(!s->dither_all)
563 remove_dithering(s);
2aa2c5c4
JR
564}
565
8b60bbbf 566/**
5066f515 567 * Stereo rematrixing.
8b60bbbf
JR
568 * reference: Section 7.5.4 Rematrixing : Decoding Technique
569 */
d802d7ca 570static void do_rematrixing(AC3DecodeContext *s)
1b293437 571{
8b60bbbf 572 int bnd, i;
2fbbd087 573 int end, bndend;
a4de6dd2 574 int tmp0, tmp1;
2fbbd087 575
d802d7ca 576 end = FFMIN(s->end_freq[1], s->end_freq[2]);
1b293437 577
d802d7ca
JR
578 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
579 if(s->rematrixing_flags[bnd]) {
227322b8
JR
580 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
581 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
a4de6dd2
JR
582 tmp0 = s->fixed_coeffs[1][i];
583 tmp1 = s->fixed_coeffs[2][i];
584 s->fixed_coeffs[1][i] = tmp0 + tmp1;
585 s->fixed_coeffs[2][i] = tmp0 - tmp1;
8b60bbbf
JR
586 }
587 }
1b293437
JR
588 }
589}
2aa2c5c4 590
5066f515 591/**
5066f515
JR
592 * Inverse MDCT Transform.
593 * Convert frequency domain coefficients to time-domain audio samples.
594 * reference: Section 7.9.4 Transformation Equations
595 */
38dae9c3 596static inline void do_imdct(AC3DecodeContext *s, int channels)
486637af 597{
0de73a46 598 int ch;
7b4076a7 599
e2270b4e 600 for (ch=1; ch<=channels; ch++) {
d802d7ca 601 if (s->block_switch[ch]) {
916d5d6c
LM
602 int i;
603 float *x = s->tmp_output+128;
604 for(i=0; i<128; i++)
605 x[i] = s->transform_coeffs[ch][2*i];
606 ff_imdct_half(&s->imdct_256, s->tmp_output, x);
72745cff 607 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, s->add_bias, 128);
916d5d6c
LM
608 for(i=0; i<128; i++)
609 x[i] = s->transform_coeffs[ch][2*i+1];
610 ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
eaf84d97 611 } else {
916d5d6c 612 ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
72745cff 613 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, s->add_bias, 128);
916d5d6c 614 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
eaf84d97 615 }
486637af
JR
616 }
617}
618
3bbb0bf8 619/**
5066f515 620 * Downmix the output to mono or stereo.
3bbb0bf8 621 */
38dae9c3
JR
622static void ac3_downmix(AC3DecodeContext *s,
623 float samples[AC3_MAX_CHANNELS][256], int ch_offset)
3bbb0bf8
JR
624{
625 int i, j;
9d10e6e6 626 float v0, v1;
3bbb0bf8
JR
627
628 for(i=0; i<256; i++) {
9d10e6e6 629 v0 = v1 = 0.0f;
b35c67e5 630 for(j=0; j<s->fbw_channels; j++) {
38dae9c3
JR
631 v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
632 v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
3bbb0bf8 633 }
d8870f12
JR
634 v0 *= s->downmix_coeff_adjust[0];
635 v1 *= s->downmix_coeff_adjust[1];
b35c67e5 636 if(s->output_mode == AC3_CHMODE_MONO) {
38dae9c3 637 samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
b35c67e5 638 } else if(s->output_mode == AC3_CHMODE_STEREO) {
38dae9c3
JR
639 samples[ ch_offset][i] = v0;
640 samples[1+ch_offset][i] = v1;
3bbb0bf8
JR
641 }
642 }
643}
644
5066f515 645/**
38dae9c3
JR
646 * Upmix delay samples from stereo to original channel layout.
647 */
648static void ac3_upmix_delay(AC3DecodeContext *s)
649{
916d5d6c 650 int channel_data_size = 128*sizeof(float);
38dae9c3
JR
651 switch(s->channel_mode) {
652 case AC3_CHMODE_DUALMONO:
653 case AC3_CHMODE_STEREO:
654 /* upmix mono to stereo */
655 memcpy(s->delay[1], s->delay[0], channel_data_size);
656 break;
657 case AC3_CHMODE_2F2R:
658 memset(s->delay[3], 0, channel_data_size);
659 case AC3_CHMODE_2F1R:
660 memset(s->delay[2], 0, channel_data_size);
661 break;
662 case AC3_CHMODE_3F2R:
663 memset(s->delay[4], 0, channel_data_size);
664 case AC3_CHMODE_3F1R:
665 memset(s->delay[3], 0, channel_data_size);
666 case AC3_CHMODE_3F:
667 memcpy(s->delay[2], s->delay[1], channel_data_size);
668 memset(s->delay[1], 0, channel_data_size);
669 break;
670 }
671}
672
673/**
022845ed 674 * Decode a single audio block from the AC-3 bitstream.
c7cfc48f 675 */
022845ed 676static int decode_audio_block(AC3DecodeContext *s, int blk)
2aa2c5c4 677{
d802d7ca
JR
678 int fbw_channels = s->fbw_channels;
679 int channel_mode = s->channel_mode;
0bff58a5 680 int i, bnd, seg, ch;
38dae9c3
JR
681 int different_transforms;
682 int downmix_output;
54624396 683 int cpl_in_use;
d802d7ca 684 GetBitContext *gbc = &s->gbc;
7b4076a7 685 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
1b293437 686
7b4076a7
JR
687 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
688
5066f515 689 /* block switch flags */
38dae9c3
JR
690 different_transforms = 0;
691 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 692 s->block_switch[ch] = get_bits1(gbc);
38dae9c3
JR
693 if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
694 different_transforms = 1;
695 }
98a27a8a 696
5066f515 697 /* dithering flags */
d802d7ca 698 s->dither_all = 1;
e2270b4e 699 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca
JR
700 s->dither_flag[ch] = get_bits1(gbc);
701 if(!s->dither_flag[ch])
702 s->dither_all = 0;
60f07fad 703 }
98a27a8a 704
77416325 705 /* dynamic range */
d802d7ca 706 i = !(s->channel_mode);
77416325 707 do {
23c8cb89 708 if(get_bits1(gbc)) {
d802d7ca 709 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
1b70d88b 710 s->avctx->drc_scale)+1.0;
9fc1ab72 711 } else if(blk == 0) {
d802d7ca 712 s->dynamic_range[i] = 1.0f;
9fc1ab72 713 }
77416325 714 } while(i--);
98a27a8a 715
5066f515 716 /* coupling strategy */
23c8cb89 717 if (get_bits1(gbc)) {
7b4076a7 718 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
4760aec6
JR
719 s->cpl_in_use[blk] = get_bits1(gbc);
720 if (s->cpl_in_use[blk]) {
5066f515 721 /* coupling in use */
e2270b4e 722 int cpl_begin_freq, cpl_end_freq;
b6acc57f 723
3af91313
JR
724 if (channel_mode < AC3_CHMODE_STEREO) {
725 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
726 return -1;
727 }
728
5066f515 729 /* determine which channels are coupled */
e2270b4e 730 for (ch = 1; ch <= fbw_channels; ch++)
d802d7ca 731 s->channel_in_cpl[ch] = get_bits1(gbc);
98a27a8a 732
5066f515 733 /* phase flags in use */
e59cc205 734 if (channel_mode == AC3_CHMODE_STEREO)
d802d7ca 735 s->phase_flags_in_use = get_bits1(gbc);
98a27a8a 736
5066f515 737 /* coupling frequency range and band structure */
23c8cb89
JR
738 cpl_begin_freq = get_bits(gbc, 4);
739 cpl_end_freq = get_bits(gbc, 4);
e2270b4e 740 if (3 + cpl_end_freq - cpl_begin_freq < 0) {
d802d7ca 741 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
00585845 742 return -1;
98a27a8a 743 }
d802d7ca
JR
744 s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
745 s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
746 s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
747 for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
23c8cb89 748 if (get_bits1(gbc)) {
d802d7ca
JR
749 s->cpl_band_struct[bnd] = 1;
750 s->num_cpl_bands--;
1b293437 751 }
eaf84d97 752 }
4bc829bb 753 s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
878c40a1 754 } else {
5066f515 755 /* coupling not in use */
e2270b4e 756 for (ch = 1; ch <= fbw_channels; ch++)
d802d7ca 757 s->channel_in_cpl[ch] = 0;
1b293437 758 }
82a591d8
JR
759 } else if (!blk) {
760 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
761 return -1;
54624396 762 } else {
4760aec6 763 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1b293437 764 }
4760aec6 765 cpl_in_use = s->cpl_in_use[blk];
98a27a8a 766
5066f515 767 /* coupling coordinates */
54624396 768 if (cpl_in_use) {
e2270b4e 769 int cpl_coords_exist = 0;
98a27a8a 770
e2270b4e 771 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 772 if (s->channel_in_cpl[ch]) {
23c8cb89 773 if (get_bits1(gbc)) {
e2270b4e
JR
774 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
775 cpl_coords_exist = 1;
23c8cb89 776 master_cpl_coord = 3 * get_bits(gbc, 2);
d802d7ca 777 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
23c8cb89
JR
778 cpl_coord_exp = get_bits(gbc, 4);
779 cpl_coord_mant = get_bits(gbc, 4);
e2270b4e 780 if (cpl_coord_exp == 15)
a4de6dd2 781 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
486637af 782 else
a4de6dd2
JR
783 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
784 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
486637af 785 }
82a591d8
JR
786 } else if (!blk) {
787 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
788 return -1;
486637af 789 }
eaf84d97
JR
790 }
791 }
5066f515 792 /* phase flags */
b02fbf75 793 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
d802d7ca 794 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
b02fbf75 795 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
eaf84d97
JR
796 }
797 }
2aa2c5c4 798 }
98a27a8a 799
5066f515 800 /* stereo rematrixing strategy and band structure */
e59cc205 801 if (channel_mode == AC3_CHMODE_STEREO) {
82a6c481 802 if (get_bits1(gbc)) {
d802d7ca 803 s->num_rematrixing_bands = 4;
54624396 804 if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
d802d7ca
JR
805 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
806 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
807 s->rematrixing_flags[bnd] = get_bits1(gbc);
82a591d8
JR
808 } else if (!blk) {
809 av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
810 return -1;
1b293437 811 }
98a27a8a
JR
812 }
813
5066f515 814 /* exponent strategies for each channel */
da04be10
JR
815 s->exp_strategy[blk][CPL_CH] = EXP_REUSE;
816 s->exp_strategy[blk][s->lfe_ch] = EXP_REUSE;
54624396 817 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
da04be10
JR
818 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
819 if(s->exp_strategy[blk][ch] != EXP_REUSE)
7b4076a7
JR
820 bit_alloc_stages[ch] = 3;
821 }
822
5066f515 823 /* channel bandwidth */
e2270b4e 824 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 825 s->start_freq[ch] = 0;
da04be10 826 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
b85a15fe 827 int group_size;
d802d7ca
JR
828 int prev = s->end_freq[ch];
829 if (s->channel_in_cpl[ch])
830 s->end_freq[ch] = s->start_freq[CPL_CH];
00585845 831 else {
23c8cb89 832 int bandwidth_code = get_bits(gbc, 6);
e2270b4e 833 if (bandwidth_code > 60) {
d802d7ca 834 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
00585845
JR
835 return -1;
836 }
d802d7ca 837 s->end_freq[ch] = bandwidth_code * 3 + 73;
1b293437 838 }
da04be10 839 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
b85a15fe 840 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
d802d7ca 841 if(blk > 0 && s->end_freq[ch] != prev)
7b4076a7 842 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00585845 843 }
eaf84d97 844 }
da04be10 845 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
b85a15fe 846 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
da04be10 847 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
b85a15fe 848 }
7b4076a7 849
5066f515 850 /* decode exponents for each channel */
54624396 851 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
da04be10 852 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
d802d7ca 853 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
da04be10 854 decode_exponents(gbc, s->exp_strategy[blk][ch],
b85a15fe 855 s->num_exp_groups[ch], s->dexps[ch][0],
d802d7ca
JR
856 &s->dexps[ch][s->start_freq[ch]+!!ch]);
857 if(ch != CPL_CH && ch != s->lfe_ch)
23c8cb89 858 skip_bits(gbc, 2); /* skip gainrng */
1b293437 859 }
eaf84d97 860 }
98a27a8a 861
5066f515 862 /* bit allocation information */
23c8cb89 863 if (get_bits1(gbc)) {
d802d7ca
JR
864 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
865 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
866 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
867 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
868 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
54624396 869 for(ch=!cpl_in_use; ch<=s->channels; ch++)
7b4076a7 870 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
82a591d8
JR
871 } else if (!blk) {
872 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
873 return -1;
1b293437 874 }
98a27a8a 875
5066f515 876 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
23c8cb89 877 if (get_bits1(gbc)) {
4611b64e 878 int csnr;
23c8cb89 879 csnr = (get_bits(gbc, 6) - 15) << 4;
54624396 880 for (ch = !cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
d802d7ca
JR
881 s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
882 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1b293437 883 }
7b4076a7 884 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
82a591d8
JR
885 } else if (!blk) {
886 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
887 return -1;
1b293437 888 }
98a27a8a 889
5066f515 890 /* coupling leak information */
54624396 891 if (cpl_in_use) {
43ad93a4 892 if (get_bits1(gbc)) {
93a2c8c1
JR
893 s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
894 s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
895 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
896 } else if (!blk) {
897 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
898 return -1;
899 }
43ad93a4 900 }
98a27a8a 901
5066f515 902 /* delta bit allocation information */
23c8cb89 903 if (get_bits1(gbc)) {
5066f515 904 /* delta bit allocation exists (strategy) */
54624396 905 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca
JR
906 s->dba_mode[ch] = get_bits(gbc, 2);
907 if (s->dba_mode[ch] == DBA_RESERVED) {
908 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1b293437
JR
909 return -1;
910 }
7b4076a7 911 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 912 }
5066f515 913 /* channel delta offset, len and bit allocation */
54624396 914 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca
JR
915 if (s->dba_mode[ch] == DBA_NEW) {
916 s->dba_nsegs[ch] = get_bits(gbc, 3);
917 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
918 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
919 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
920 s->dba_values[ch][seg] = get_bits(gbc, 3);
1b293437 921 }
e25973a1
JR
922 /* run last 2 bit allocation stages if new dba values */
923 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 924 }
eaf84d97 925 }
9fc1ab72 926 } else if(blk == 0) {
d802d7ca
JR
927 for(ch=0; ch<=s->channels; ch++) {
928 s->dba_mode[ch] = DBA_NONE;
9fc1ab72 929 }
1b293437 930 }
00585845 931
5066f515 932 /* Bit allocation */
54624396 933 for(ch=!cpl_in_use; ch<=s->channels; ch++) {
7b4076a7
JR
934 if(bit_alloc_stages[ch] > 2) {
935 /* Exponent mapping into PSD and PSD integration */
d802d7ca
JR
936 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
937 s->start_freq[ch], s->end_freq[ch],
938 s->psd[ch], s->band_psd[ch]);
eaf84d97 939 }
7b4076a7
JR
940 if(bit_alloc_stages[ch] > 1) {
941 /* Compute excitation function, Compute masking curve, and
942 Apply delta bit allocation */
d802d7ca
JR
943 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
944 s->start_freq[ch], s->end_freq[ch],
945 s->fast_gain[ch], (ch == s->lfe_ch),
946 s->dba_mode[ch], s->dba_nsegs[ch],
947 s->dba_offsets[ch], s->dba_lengths[ch],
948 s->dba_values[ch], s->mask[ch]);
eaf84d97 949 }
7b4076a7
JR
950 if(bit_alloc_stages[ch] > 0) {
951 /* Compute bit allocation */
d802d7ca
JR
952 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
953 s->start_freq[ch], s->end_freq[ch],
954 s->snr_offset[ch],
955 s->bit_alloc_params.floor,
687671f0 956 ff_ac3_bap_tab, s->bap[ch]);
eaf84d97 957 }
2fbbd087 958 }
98a27a8a 959
5066f515 960 /* unused dummy data */
23c8cb89
JR
961 if (get_bits1(gbc)) {
962 int skipl = get_bits(gbc, 9);
98a27a8a 963 while(skipl--)
23c8cb89 964 skip_bits(gbc, 8);
1b293437 965 }
f5cefb21 966
1b293437 967 /* unpack the transform coefficients
5066f515 968 this also uncouples channels if coupling is in use. */
ff5d419e 969 get_transform_coeffs(s);
486637af 970
1b293437 971 /* recover coefficients if rematrixing is in use */
d802d7ca
JR
972 if(s->channel_mode == AC3_CHMODE_STEREO)
973 do_rematrixing(s);
1b293437 974
03726b70 975 /* apply scaling to coefficients (headroom, dynrng) */
d802d7ca 976 for(ch=1; ch<=s->channels; ch++) {
a4de6dd2 977 float gain = s->mul_bias / 4194304.0f;
d802d7ca
JR
978 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
979 gain *= s->dynamic_range[ch-1];
7bfd22f2 980 } else {
d802d7ca 981 gain *= s->dynamic_range[0];
7bfd22f2 982 }
a4de6dd2
JR
983 for(i=0; i<256; i++) {
984 s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
7bfd22f2
JR
985 }
986 }
d7bcc4ad 987
38dae9c3
JR
988 /* downmix and MDCT. order depends on whether block switching is used for
989 any channel in this block. this is because coefficients for the long
990 and short transforms cannot be mixed. */
991 downmix_output = s->channels != s->out_channels &&
992 !((s->output_mode & AC3_OUTPUT_LFEON) &&
993 s->fbw_channels == s->out_channels);
994 if(different_transforms) {
995 /* the delay samples have already been downmixed, so we upmix the delay
996 samples in order to reconstruct all channels before downmixing. */
997 if(s->downmixed) {
998 s->downmixed = 0;
999 ac3_upmix_delay(s);
1000 }
1001
1002 do_imdct(s, s->channels);
1003
1004 if(downmix_output) {
1005 ac3_downmix(s, s->output, 0);
1006 }
1007 } else {
1008 if(downmix_output) {
1009 ac3_downmix(s, s->transform_coeffs, 1);
1010 }
1011
1012 if(!s->downmixed) {
1013 s->downmixed = 1;
916d5d6c 1014 // FIXME delay[] is half the size of the other downmixes
38dae9c3
JR
1015 ac3_downmix(s, s->delay, 0);
1016 }
486637af 1017
38dae9c3 1018 do_imdct(s, s->out_channels);
3bbb0bf8
JR
1019 }
1020
4e092320 1021 return 0;
486637af
JR
1022}
1023
5066f515
JR
1024/**
1025 * Decode a single AC-3 frame.
c7cfc48f 1026 */
98f6dfa6
JR
1027static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1028 const uint8_t *buf, int buf_size)
1b293437 1029{
0345fade 1030 AC3DecodeContext *s = avctx->priv_data;
00585845 1031 int16_t *out_samples = (int16_t *)data;
72745cff 1032 int blk, ch, err;
d7bcc4ad 1033
5066f515 1034 /* initialize the GetBitContext with the start of valid AC-3 Frame */
509fdb0b 1035 if (s->input_buffer) {
c33a1967
JR
1036 /* copy input buffer to decoder context to avoid reading past the end
1037 of the buffer, which can be caused by a damaged input stream. */
1038 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1039 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1040 } else {
984ff38a 1041 init_get_bits(&s->gbc, buf, buf_size * 8);
c33a1967 1042 }
00585845 1043
5066f515 1044 /* parse the syncinfo */
c78c6d6c 1045 *data_size = 0;
4397d95c 1046 err = parse_frame_header(s);
c78c6d6c
JR
1047
1048 /* check that reported frame size fits in input buffer */
1049 if(s->frame_size > buf_size) {
1050 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1051 err = AC3_PARSE_ERROR_FRAME_SIZE;
1052 }
1053
1054 /* check for crc mismatch */
1055 if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1056 if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1057 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
fbe52e41 1058 err = AC3_PARSE_ERROR_CRC;
c78c6d6c
JR
1059 }
1060 }
1061
fbe52e41 1062 if(err && err != AC3_PARSE_ERROR_CRC) {
3df88093
JR
1063 switch(err) {
1064 case AC3_PARSE_ERROR_SYNC:
c78c6d6c 1065 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
7af26d14 1066 return -1;
3df88093
JR
1067 case AC3_PARSE_ERROR_BSID:
1068 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1069 break;
1070 case AC3_PARSE_ERROR_SAMPLE_RATE:
1071 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1072 break;
1073 case AC3_PARSE_ERROR_FRAME_SIZE:
1074 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1075 break;
79b25a27 1076 case AC3_PARSE_ERROR_FRAME_TYPE:
aa5d6be8
JR
1077 /* skip frame if CRC is ok. otherwise use error concealment. */
1078 /* TODO: add support for substreams and dependent frames */
1079 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1080 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1081 return s->frame_size;
1082 } else {
4921bbba 1083 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
aa5d6be8 1084 }
4e6eeaf0 1085 break;
3df88093
JR
1086 default:
1087 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1088 break;
1089 }
1b293437 1090 }
2aa2c5c4 1091
eccba2bc
JR
1092 /* if frame is ok, set audio parameters */
1093 if (!err) {
3336110a
JR
1094 avctx->sample_rate = s->sample_rate;
1095 avctx->bit_rate = s->bit_rate;
1096
1097 /* channel config */
1098 s->out_channels = s->channels;
eccba2bc
JR
1099 s->output_mode = s->channel_mode;
1100 if(s->lfe_on)
1101 s->output_mode |= AC3_OUTPUT_LFEON;
3336110a
JR
1102 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1103 avctx->request_channels < s->channels) {
1104 s->out_channels = avctx->request_channels;
1105 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1106 }
1107 avctx->channels = s->out_channels;
1b293437 1108
3336110a
JR
1109 /* set downmixing coefficients if needed */
1110 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1111 s->fbw_channels == s->out_channels)) {
1112 set_downmix_coeffs(s);
1113 }
eccba2bc
JR
1114 } else if (!s->out_channels) {
1115 s->out_channels = avctx->channels;
1116 if(s->out_channels < s->channels)
1117 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
ecfe94b2 1118 }
f0b3a7ba 1119
022845ed 1120 /* decode the audio blocks */
6730e9f3 1121 for (blk = 0; blk < s->num_blocks; blk++) {
72745cff 1122 const float *output[s->out_channels];
022845ed
JR
1123 if (!err && decode_audio_block(s, blk)) {
1124 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1b293437 1125 }
72745cff
LM
1126 for (ch = 0; ch < s->out_channels; ch++)
1127 output[ch] = s->output[ch];
1128 s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1129 out_samples += 256 * s->out_channels;
1b293437 1130 }
6730e9f3 1131 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
d802d7ca 1132 return s->frame_size;
2aa2c5c4 1133}
1b293437 1134
5066f515
JR
1135/**
1136 * Uninitialize the AC-3 decoder.
c7cfc48f 1137 */
98a6fff9 1138static av_cold int ac3_decode_end(AVCodecContext *avctx)
1b293437 1139{
0345fade 1140 AC3DecodeContext *s = avctx->priv_data;
d802d7ca
JR
1141 ff_mdct_end(&s->imdct_512);
1142 ff_mdct_end(&s->imdct_256);
c7cfc48f 1143
509fdb0b
JR
1144 av_freep(&s->input_buffer);
1145
1b293437
JR
1146 return 0;
1147}
1148
fa67992d 1149AVCodec ac3_decoder = {
e6bca37c
JR
1150 .name = "ac3",
1151 .type = CODEC_TYPE_AUDIO,
1152 .id = CODEC_ID_AC3,
1153 .priv_data_size = sizeof (AC3DecodeContext),
1154 .init = ac3_decode_init,
1155 .close = ac3_decode_end,
1156 .decode = ac3_decode_frame,
fe4bf374 1157 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 / AC-3"),
1b293437 1158};