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