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