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