simplify, pass AVStream directly instead of index
[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 442/**
e522bd49 443 * Decode the transform coefficients for a particular channel
5066f515
JR
444 * reference: Section 7.3 Quantization and Decoding of Mantissas
445 */
e43b29ab 446static void ac3_decode_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
6a68105e 551static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
bf09b550
JR
552 mant_groups *m)
553{
554 if (!s->channel_uses_aht[ch]) {
6a68105e 555 ac3_decode_transform_coeffs_ch(s, ch, m);
bf09b550
JR
556 } else {
557 /* if AHT is used, mantissas for all blocks are encoded in the first
558 block of the frame. */
559 int bin;
e43b29ab 560 /*
bf09b550 561 if (!blk)
6a68105e 562 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
e43b29ab 563 */
bf09b550
JR
564 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
565 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
566 }
567 }
568}
bf09b550 569
5066f515 570/**
164e169f 571 * Decode the transform coefficients.
c7cfc48f 572 */
e43b29ab 573static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
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 */
e43b29ab 583 decode_transform_coeffs_ch(s, blk, 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) {
e43b29ab 588 decode_transform_coeffs_ch(s, blk, 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
ea364c74 601 /* zero the dithered coefficients for appropriate channels */
86662b1c 602 remove_dithering(s);
2aa2c5c4
JR
603}
604
8b60bbbf 605/**
5066f515 606 * Stereo rematrixing.
8b60bbbf
JR
607 * reference: Section 7.5.4 Rematrixing : Decoding Technique
608 */
d802d7ca 609static void do_rematrixing(AC3DecodeContext *s)
1b293437 610{
8b60bbbf 611 int bnd, i;
2fbbd087 612 int end, bndend;
a4de6dd2 613 int tmp0, tmp1;
2fbbd087 614
d802d7ca 615 end = FFMIN(s->end_freq[1], s->end_freq[2]);
1b293437 616
d802d7ca
JR
617 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
618 if(s->rematrixing_flags[bnd]) {
227322b8
JR
619 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
620 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
a4de6dd2
JR
621 tmp0 = s->fixed_coeffs[1][i];
622 tmp1 = s->fixed_coeffs[2][i];
623 s->fixed_coeffs[1][i] = tmp0 + tmp1;
624 s->fixed_coeffs[2][i] = tmp0 - tmp1;
8b60bbbf
JR
625 }
626 }
1b293437
JR
627 }
628}
2aa2c5c4 629
5066f515 630/**
5066f515
JR
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;
3b6516f7
LM
638 float add_bias = s->add_bias;
639 if(s->out_channels==1 && channels>1)
640 add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
7b4076a7 641
e2270b4e 642 for (ch=1; ch<=channels; ch++) {
d802d7ca 643 if (s->block_switch[ch]) {
916d5d6c
LM
644 int i;
645 float *x = s->tmp_output+128;
646 for(i=0; i<128; i++)
647 x[i] = s->transform_coeffs[ch][2*i];
648 ff_imdct_half(&s->imdct_256, s->tmp_output, x);
3b6516f7 649 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
916d5d6c
LM
650 for(i=0; i<128; i++)
651 x[i] = s->transform_coeffs[ch][2*i+1];
652 ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
eaf84d97 653 } else {
916d5d6c 654 ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
3b6516f7 655 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
916d5d6c 656 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
eaf84d97 657 }
486637af
JR
658 }
659}
660
3bbb0bf8 661/**
5066f515 662 * Downmix the output to mono or stereo.
3bbb0bf8 663 */
ac2e5564 664void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
3bbb0bf8
JR
665{
666 int i, j;
9d10e6e6 667 float v0, v1;
ac2e5564
LM
668 if(out_ch == 2) {
669 for(i=0; i<len; i++) {
557ac0c4 670 v0 = v1 = 0.0f;
ac2e5564
LM
671 for(j=0; j<in_ch; j++) {
672 v0 += samples[j][i] * matrix[j][0];
673 v1 += samples[j][i] * matrix[j][1];
557ac0c4
LM
674 }
675 samples[0][i] = v0;
676 samples[1][i] = v1;
3bbb0bf8 677 }
ac2e5564
LM
678 } else if(out_ch == 1) {
679 for(i=0; i<len; i++) {
557ac0c4 680 v0 = 0.0f;
ac2e5564
LM
681 for(j=0; j<in_ch; j++)
682 v0 += samples[j][i] * matrix[j][0];
557ac0c4 683 samples[0][i] = v0;
3bbb0bf8
JR
684 }
685 }
686}
687
5066f515 688/**
38dae9c3
JR
689 * Upmix delay samples from stereo to original channel layout.
690 */
691static void ac3_upmix_delay(AC3DecodeContext *s)
692{
e6300276 693 int channel_data_size = sizeof(s->delay[0]);
38dae9c3
JR
694 switch(s->channel_mode) {
695 case AC3_CHMODE_DUALMONO:
696 case AC3_CHMODE_STEREO:
697 /* upmix mono to stereo */
698 memcpy(s->delay[1], s->delay[0], channel_data_size);
699 break;
700 case AC3_CHMODE_2F2R:
701 memset(s->delay[3], 0, channel_data_size);
702 case AC3_CHMODE_2F1R:
703 memset(s->delay[2], 0, channel_data_size);
704 break;
705 case AC3_CHMODE_3F2R:
706 memset(s->delay[4], 0, channel_data_size);
707 case AC3_CHMODE_3F1R:
708 memset(s->delay[3], 0, channel_data_size);
709 case AC3_CHMODE_3F:
710 memcpy(s->delay[2], s->delay[1], channel_data_size);
711 memset(s->delay[1], 0, channel_data_size);
712 break;
713 }
714}
715
716/**
022845ed 717 * Decode a single audio block from the AC-3 bitstream.
c7cfc48f 718 */
022845ed 719static int decode_audio_block(AC3DecodeContext *s, int blk)
2aa2c5c4 720{
d802d7ca
JR
721 int fbw_channels = s->fbw_channels;
722 int channel_mode = s->channel_mode;
0bff58a5 723 int i, bnd, seg, ch;
38dae9c3
JR
724 int different_transforms;
725 int downmix_output;
54624396 726 int cpl_in_use;
d802d7ca 727 GetBitContext *gbc = &s->gbc;
7b4076a7 728 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
1b293437 729
7b4076a7
JR
730 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
731
5066f515 732 /* block switch flags */
38dae9c3 733 different_transforms = 0;
bf09b550 734 if (s->block_switch_syntax) {
ab2a942a
JR
735 for (ch = 1; ch <= fbw_channels; ch++) {
736 s->block_switch[ch] = get_bits1(gbc);
737 if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
738 different_transforms = 1;
739 }
bf09b550 740 }
98a27a8a 741
5066f515 742 /* dithering flags */
bf09b550 743 if (s->dither_flag_syntax) {
ab2a942a
JR
744 for (ch = 1; ch <= fbw_channels; ch++) {
745 s->dither_flag[ch] = get_bits1(gbc);
ab2a942a 746 }
bf09b550 747 }
98a27a8a 748
77416325 749 /* dynamic range */
d802d7ca 750 i = !(s->channel_mode);
77416325 751 do {
23c8cb89 752 if(get_bits1(gbc)) {
d802d7ca 753 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
1b70d88b 754 s->avctx->drc_scale)+1.0;
9fc1ab72 755 } else if(blk == 0) {
d802d7ca 756 s->dynamic_range[i] = 1.0f;
9fc1ab72 757 }
77416325 758 } while(i--);
98a27a8a 759
6fafb020
JR
760 /* spectral extension strategy */
761 if (s->eac3 && (!blk || get_bits1(gbc))) {
762 if (get_bits1(gbc)) {
763 av_log_missing_feature(s->avctx, "Spectral extension", 1);
764 return -1;
765 }
766 /* TODO: parse spectral extension strategy info */
767 }
768
769 /* TODO: spectral extension coordinates */
770
5066f515 771 /* coupling strategy */
225c3042 772 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
7b4076a7 773 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
6fafb020 774 if (!s->eac3)
0569993e 775 s->cpl_in_use[blk] = get_bits1(gbc);
4760aec6 776 if (s->cpl_in_use[blk]) {
5066f515 777 /* coupling in use */
e2270b4e 778 int cpl_begin_freq, cpl_end_freq;
b6acc57f 779
3af91313
JR
780 if (channel_mode < AC3_CHMODE_STEREO) {
781 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
782 return -1;
783 }
784
6fafb020
JR
785 /* check for enhanced coupling */
786 if (s->eac3 && get_bits1(gbc)) {
787 /* TODO: parse enhanced coupling strategy info */
788 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
789 return -1;
790 }
791
5066f515 792 /* determine which channels are coupled */
6fafb020
JR
793 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
794 s->channel_in_cpl[1] = 1;
795 s->channel_in_cpl[2] = 1;
796 } else {
0569993e
JR
797 for (ch = 1; ch <= fbw_channels; ch++)
798 s->channel_in_cpl[ch] = get_bits1(gbc);
6fafb020 799 }
98a27a8a 800
5066f515 801 /* phase flags in use */
e59cc205 802 if (channel_mode == AC3_CHMODE_STEREO)
d802d7ca 803 s->phase_flags_in_use = get_bits1(gbc);
98a27a8a 804
6fafb020
JR
805 /* coupling frequency range */
806 /* TODO: modify coupling end freq if spectral extension is used */
23c8cb89
JR
807 cpl_begin_freq = get_bits(gbc, 4);
808 cpl_end_freq = get_bits(gbc, 4);
e2270b4e 809 if (3 + cpl_end_freq - cpl_begin_freq < 0) {
d802d7ca 810 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
00585845 811 return -1;
98a27a8a 812 }
d802d7ca
JR
813 s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
814 s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
815 s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
6fafb020
JR
816
817 /* coupling band structure */
818 if (!s->eac3 || get_bits1(gbc)) {
0569993e 819 for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
6fafb020 820 s->cpl_band_struct[bnd] = get_bits1(gbc);
1b293437 821 }
6fafb020 822 } else if (!blk) {
0ffea243
JR
823 memcpy(s->cpl_band_struct,
824 &ff_eac3_default_cpl_band_struct[cpl_begin_freq+1],
825 s->num_cpl_subbands-1);
eaf84d97 826 }
4bc829bb 827 s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
6fafb020
JR
828
829 /* calculate number of coupling bands based on band structure */
830 for (bnd = 0; bnd < s->num_cpl_subbands-1; bnd++) {
831 s->num_cpl_bands -= s->cpl_band_struct[bnd];
832 }
878c40a1 833 } else {
5066f515 834 /* coupling not in use */
6fafb020 835 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 836 s->channel_in_cpl[ch] = 0;
6fafb020
JR
837 s->first_cpl_coords[ch] = 1;
838 }
63d72fb1 839 s->first_cpl_leak = s->eac3;
6fafb020 840 s->phase_flags_in_use = 0;
1b293437 841 }
6fafb020
JR
842 } else if (!s->eac3) {
843 if(!blk) {
0569993e
JR
844 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
845 return -1;
846 } else {
847 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
848 }
6fafb020 849 }
4760aec6 850 cpl_in_use = s->cpl_in_use[blk];
98a27a8a 851
5066f515 852 /* coupling coordinates */
54624396 853 if (cpl_in_use) {
e2270b4e 854 int cpl_coords_exist = 0;
98a27a8a 855
e2270b4e 856 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 857 if (s->channel_in_cpl[ch]) {
225c3042 858 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
e2270b4e 859 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
225c3042 860 s->first_cpl_coords[ch] = 0;
e2270b4e 861 cpl_coords_exist = 1;
23c8cb89 862 master_cpl_coord = 3 * get_bits(gbc, 2);
d802d7ca 863 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
23c8cb89
JR
864 cpl_coord_exp = get_bits(gbc, 4);
865 cpl_coord_mant = get_bits(gbc, 4);
e2270b4e 866 if (cpl_coord_exp == 15)
a4de6dd2 867 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
486637af 868 else
a4de6dd2
JR
869 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
870 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
486637af 871 }
82a591d8
JR
872 } else if (!blk) {
873 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
874 return -1;
486637af 875 }
225c3042
JR
876 } else {
877 /* channel not in coupling */
878 s->first_cpl_coords[ch] = 1;
eaf84d97
JR
879 }
880 }
5066f515 881 /* phase flags */
b02fbf75 882 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
d802d7ca 883 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
b02fbf75 884 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
eaf84d97
JR
885 }
886 }
2aa2c5c4 887 }
98a27a8a 888
5066f515 889 /* stereo rematrixing strategy and band structure */
e59cc205 890 if (channel_mode == AC3_CHMODE_STEREO) {
6fafb020 891 if ((s->eac3 && !blk) || get_bits1(gbc)) {
d802d7ca 892 s->num_rematrixing_bands = 4;
54624396 893 if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
d802d7ca
JR
894 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
895 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
896 s->rematrixing_flags[bnd] = get_bits1(gbc);
82a591d8
JR
897 } else if (!blk) {
898 av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
899 return -1;
1b293437 900 }
98a27a8a
JR
901 }
902
5066f515 903 /* exponent strategies for each channel */
54624396 904 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
6b4bfed9 905 if (!s->eac3)
aec0407f 906 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
da04be10 907 if(s->exp_strategy[blk][ch] != EXP_REUSE)
7b4076a7
JR
908 bit_alloc_stages[ch] = 3;
909 }
910
5066f515 911 /* channel bandwidth */
e2270b4e 912 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 913 s->start_freq[ch] = 0;
da04be10 914 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
b85a15fe 915 int group_size;
d802d7ca
JR
916 int prev = s->end_freq[ch];
917 if (s->channel_in_cpl[ch])
918 s->end_freq[ch] = s->start_freq[CPL_CH];
00585845 919 else {
23c8cb89 920 int bandwidth_code = get_bits(gbc, 6);
e2270b4e 921 if (bandwidth_code > 60) {
d802d7ca 922 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
00585845
JR
923 return -1;
924 }
d802d7ca 925 s->end_freq[ch] = bandwidth_code * 3 + 73;
1b293437 926 }
da04be10 927 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
b85a15fe 928 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
d802d7ca 929 if(blk > 0 && s->end_freq[ch] != prev)
7b4076a7 930 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00585845 931 }
eaf84d97 932 }
da04be10 933 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
b85a15fe 934 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
da04be10 935 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
b85a15fe 936 }
7b4076a7 937
5066f515 938 /* decode exponents for each channel */
54624396 939 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
da04be10 940 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
d802d7ca 941 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
da04be10 942 decode_exponents(gbc, s->exp_strategy[blk][ch],
b85a15fe 943 s->num_exp_groups[ch], s->dexps[ch][0],
d802d7ca
JR
944 &s->dexps[ch][s->start_freq[ch]+!!ch]);
945 if(ch != CPL_CH && ch != s->lfe_ch)
23c8cb89 946 skip_bits(gbc, 2); /* skip gainrng */
1b293437 947 }
eaf84d97 948 }
98a27a8a 949
5066f515 950 /* bit allocation information */
bf09b550 951 if (s->bit_allocation_syntax) {
ab2a942a
JR
952 if (get_bits1(gbc)) {
953 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
954 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
955 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
956 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
957 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
958 for(ch=!cpl_in_use; ch<=s->channels; ch++)
959 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
960 } else if (!blk) {
961 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
962 return -1;
963 }
bf09b550 964 }
98a27a8a 965
5066f515 966 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
23c8cb89 967 if (get_bits1(gbc)) {
4611b64e 968 int csnr;
23c8cb89 969 csnr = (get_bits(gbc, 6) - 15) << 4;
54624396 970 for (ch = !cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
d802d7ca
JR
971 s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
972 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1b293437 973 }
7b4076a7 974 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
82a591d8
JR
975 } else if (!blk) {
976 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
977 return -1;
1b293437 978 }
98a27a8a 979
6fafb020
JR
980 /* fast gain (E-AC-3 only) */
981 if (s->fast_gain_syntax && get_bits1(gbc)) {
982 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
983 int prev = s->fast_gain[ch];
984 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
985 /* run last 2 bit allocation stages if fast gain changes */
986 if(blk && prev != s->fast_gain[ch])
987 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
988 }
989 } else if (s->eac3 && !blk) {
990 for (ch = !cpl_in_use; ch <= s->channels; ch++)
991 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
992 }
993
994 /* E-AC-3 to AC-3 converter SNR offset */
995 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
996 skip_bits(gbc, 10); // skip converter snr offset
997 }
998
5066f515 999 /* coupling leak information */
54624396 1000 if (cpl_in_use) {
43ad93a4 1001 if (get_bits1(gbc)) {
93a2c8c1
JR
1002 s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
1003 s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
1004 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1005 } else if (!blk) {
1006 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1007 return -1;
1008 }
43ad93a4 1009 }
98a27a8a 1010
5066f515 1011 /* delta bit allocation information */
bf09b550 1012 if (s->dba_syntax && get_bits1(gbc)) {
5066f515 1013 /* delta bit allocation exists (strategy) */
54624396 1014 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca
JR
1015 s->dba_mode[ch] = get_bits(gbc, 2);
1016 if (s->dba_mode[ch] == DBA_RESERVED) {
1017 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1b293437
JR
1018 return -1;
1019 }
7b4076a7 1020 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1021 }
5066f515 1022 /* channel delta offset, len and bit allocation */
54624396 1023 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca
JR
1024 if (s->dba_mode[ch] == DBA_NEW) {
1025 s->dba_nsegs[ch] = get_bits(gbc, 3);
1026 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1027 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1028 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1029 s->dba_values[ch][seg] = get_bits(gbc, 3);
1b293437 1030 }
e25973a1
JR
1031 /* run last 2 bit allocation stages if new dba values */
1032 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1033 }
eaf84d97 1034 }
9fc1ab72 1035 } else if(blk == 0) {
d802d7ca
JR
1036 for(ch=0; ch<=s->channels; ch++) {
1037 s->dba_mode[ch] = DBA_NONE;
9fc1ab72 1038 }
1b293437 1039 }
00585845 1040
5066f515 1041 /* Bit allocation */
54624396 1042 for(ch=!cpl_in_use; ch<=s->channels; ch++) {
7b4076a7
JR
1043 if(bit_alloc_stages[ch] > 2) {
1044 /* Exponent mapping into PSD and PSD integration */
d802d7ca
JR
1045 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1046 s->start_freq[ch], s->end_freq[ch],
1047 s->psd[ch], s->band_psd[ch]);
eaf84d97 1048 }
7b4076a7
JR
1049 if(bit_alloc_stages[ch] > 1) {
1050 /* Compute excitation function, Compute masking curve, and
1051 Apply delta bit allocation */
d802d7ca
JR
1052 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1053 s->start_freq[ch], s->end_freq[ch],
1054 s->fast_gain[ch], (ch == s->lfe_ch),
1055 s->dba_mode[ch], s->dba_nsegs[ch],
1056 s->dba_offsets[ch], s->dba_lengths[ch],
1057 s->dba_values[ch], s->mask[ch]);
eaf84d97 1058 }
7b4076a7
JR
1059 if(bit_alloc_stages[ch] > 0) {
1060 /* Compute bit allocation */
bf09b550
JR
1061 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1062 ff_eac3_hebap_tab : ff_ac3_bap_tab;
d802d7ca
JR
1063 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1064 s->start_freq[ch], s->end_freq[ch],
1065 s->snr_offset[ch],
1066 s->bit_alloc_params.floor,
bf09b550 1067 bap_tab, s->bap[ch]);
eaf84d97 1068 }
2fbbd087 1069 }
98a27a8a 1070
5066f515 1071 /* unused dummy data */
bf09b550 1072 if (s->skip_syntax && get_bits1(gbc)) {
23c8cb89 1073 int skipl = get_bits(gbc, 9);
98a27a8a 1074 while(skipl--)
23c8cb89 1075 skip_bits(gbc, 8);
1b293437 1076 }
f5cefb21 1077
1b293437 1078 /* unpack the transform coefficients
5066f515 1079 this also uncouples channels if coupling is in use. */
e43b29ab 1080 decode_transform_coeffs(s, blk);
486637af 1081
bf09b550
JR
1082 /* TODO: generate enhanced coupling coordinates and uncouple */
1083
1084 /* TODO: apply spectral extension */
1085
1b293437 1086 /* recover coefficients if rematrixing is in use */
d802d7ca
JR
1087 if(s->channel_mode == AC3_CHMODE_STEREO)
1088 do_rematrixing(s);
1b293437 1089
03726b70 1090 /* apply scaling to coefficients (headroom, dynrng) */
d802d7ca 1091 for(ch=1; ch<=s->channels; ch++) {
a4de6dd2 1092 float gain = s->mul_bias / 4194304.0f;
d802d7ca
JR
1093 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1094 gain *= s->dynamic_range[ch-1];
7bfd22f2 1095 } else {
d802d7ca 1096 gain *= s->dynamic_range[0];
7bfd22f2 1097 }
911e21a3 1098 s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
7bfd22f2 1099 }
d7bcc4ad 1100
38dae9c3
JR
1101 /* downmix and MDCT. order depends on whether block switching is used for
1102 any channel in this block. this is because coefficients for the long
1103 and short transforms cannot be mixed. */
1104 downmix_output = s->channels != s->out_channels &&
1105 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1106 s->fbw_channels == s->out_channels);
1107 if(different_transforms) {
1108 /* the delay samples have already been downmixed, so we upmix the delay
1109 samples in order to reconstruct all channels before downmixing. */
1110 if(s->downmixed) {
1111 s->downmixed = 0;
1112 ac3_upmix_delay(s);
1113 }
1114
1115 do_imdct(s, s->channels);
1116
1117 if(downmix_output) {
ac2e5564 1118 s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
38dae9c3
JR
1119 }
1120 } else {
1121 if(downmix_output) {
ac2e5564 1122 s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
38dae9c3
JR
1123 }
1124
45d9d618 1125 if(downmix_output && !s->downmixed) {
38dae9c3 1126 s->downmixed = 1;
ac2e5564 1127 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
38dae9c3 1128 }
486637af 1129
38dae9c3 1130 do_imdct(s, s->out_channels);
3bbb0bf8
JR
1131 }
1132
4e092320 1133 return 0;
486637af
JR
1134}
1135
5066f515
JR
1136/**
1137 * Decode a single AC-3 frame.
c7cfc48f 1138 */
98f6dfa6
JR
1139static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1140 const uint8_t *buf, int buf_size)
1b293437 1141{
0345fade 1142 AC3DecodeContext *s = avctx->priv_data;
00585845 1143 int16_t *out_samples = (int16_t *)data;
72745cff 1144 int blk, ch, err;
d7bcc4ad 1145
5066f515 1146 /* initialize the GetBitContext with the start of valid AC-3 Frame */
509fdb0b 1147 if (s->input_buffer) {
c33a1967
JR
1148 /* copy input buffer to decoder context to avoid reading past the end
1149 of the buffer, which can be caused by a damaged input stream. */
8e33132b 1150 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
c33a1967
JR
1151 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1152 } else {
984ff38a 1153 init_get_bits(&s->gbc, buf, buf_size * 8);
c33a1967 1154 }
00585845 1155
5066f515 1156 /* parse the syncinfo */
c78c6d6c 1157 *data_size = 0;
4397d95c 1158 err = parse_frame_header(s);
c78c6d6c
JR
1159
1160 /* check that reported frame size fits in input buffer */
1161 if(s->frame_size > buf_size) {
1162 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1163 err = AC3_PARSE_ERROR_FRAME_SIZE;
1164 }
1165
1166 /* check for crc mismatch */
1167 if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1168 if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1169 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
fbe52e41 1170 err = AC3_PARSE_ERROR_CRC;
c78c6d6c
JR
1171 }
1172 }
1173
fbe52e41 1174 if(err && err != AC3_PARSE_ERROR_CRC) {
3df88093
JR
1175 switch(err) {
1176 case AC3_PARSE_ERROR_SYNC:
c78c6d6c 1177 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
7af26d14 1178 return -1;
3df88093
JR
1179 case AC3_PARSE_ERROR_BSID:
1180 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1181 break;
1182 case AC3_PARSE_ERROR_SAMPLE_RATE:
1183 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1184 break;
1185 case AC3_PARSE_ERROR_FRAME_SIZE:
1186 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1187 break;
79b25a27 1188 case AC3_PARSE_ERROR_FRAME_TYPE:
aa5d6be8
JR
1189 /* skip frame if CRC is ok. otherwise use error concealment. */
1190 /* TODO: add support for substreams and dependent frames */
1191 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1192 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1193 return s->frame_size;
1194 } else {
4921bbba 1195 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
aa5d6be8 1196 }
4e6eeaf0 1197 break;
3df88093
JR
1198 default:
1199 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1200 break;
1201 }
1b293437 1202 }
2aa2c5c4 1203
eccba2bc
JR
1204 /* if frame is ok, set audio parameters */
1205 if (!err) {
3336110a
JR
1206 avctx->sample_rate = s->sample_rate;
1207 avctx->bit_rate = s->bit_rate;
1208
1209 /* channel config */
1210 s->out_channels = s->channels;
eccba2bc
JR
1211 s->output_mode = s->channel_mode;
1212 if(s->lfe_on)
1213 s->output_mode |= AC3_OUTPUT_LFEON;
3336110a
JR
1214 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1215 avctx->request_channels < s->channels) {
1216 s->out_channels = avctx->request_channels;
1217 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1218 }
1219 avctx->channels = s->out_channels;
1b293437 1220
3336110a
JR
1221 /* set downmixing coefficients if needed */
1222 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1223 s->fbw_channels == s->out_channels)) {
1224 set_downmix_coeffs(s);
1225 }
eccba2bc
JR
1226 } else if (!s->out_channels) {
1227 s->out_channels = avctx->channels;
1228 if(s->out_channels < s->channels)
1229 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
ecfe94b2 1230 }
f0b3a7ba 1231
022845ed 1232 /* decode the audio blocks */
6730e9f3 1233 for (blk = 0; blk < s->num_blocks; blk++) {
72745cff 1234 const float *output[s->out_channels];
022845ed
JR
1235 if (!err && decode_audio_block(s, blk)) {
1236 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1b293437 1237 }
72745cff
LM
1238 for (ch = 0; ch < s->out_channels; ch++)
1239 output[ch] = s->output[ch];
1240 s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1241 out_samples += 256 * s->out_channels;
1b293437 1242 }
6730e9f3 1243 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
d802d7ca 1244 return s->frame_size;
2aa2c5c4 1245}
1b293437 1246
5066f515
JR
1247/**
1248 * Uninitialize the AC-3 decoder.
c7cfc48f 1249 */
98a6fff9 1250static av_cold int ac3_decode_end(AVCodecContext *avctx)
1b293437 1251{
0345fade 1252 AC3DecodeContext *s = avctx->priv_data;
d802d7ca
JR
1253 ff_mdct_end(&s->imdct_512);
1254 ff_mdct_end(&s->imdct_256);
c7cfc48f 1255
509fdb0b
JR
1256 av_freep(&s->input_buffer);
1257
1b293437
JR
1258 return 0;
1259}
1260
fa67992d 1261AVCodec ac3_decoder = {
e6bca37c
JR
1262 .name = "ac3",
1263 .type = CODEC_TYPE_AUDIO,
1264 .id = CODEC_ID_AC3,
1265 .priv_data_size = sizeof (AC3DecodeContext),
1266 .init = ac3_decode_init,
1267 .close = ac3_decode_end,
1268 .decode = ac3_decode_frame,
bf09b550 1269 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 (AC-3, E-AC-3)"),
1b293437 1270};