add a line break in error message text
[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 218 /* allocate context input buffer */
047599a4 219 if (avctx->error_recognition >= 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 319 } else {
1f6a594d
JR
320 s->eac3 = 1;
321 return ff_eac3_parse_header(s);
bf09b550 322 }
f0b3a7ba
JR
323}
324
325/**
326 * Set stereo downmixing coefficients based on frame header info.
327 * reference: Section 7.8.2 Downmixing Into Two Channels
328 */
329static void set_downmix_coeffs(AC3DecodeContext *s)
330{
331 int i;
30f71adc
JR
332 float cmix = gain_levels[center_levels[s->center_mix_level]];
333 float smix = gain_levels[surround_levels[s->surround_mix_level]];
557ac0c4 334 float norm0, norm1;
f0b3a7ba 335
d802d7ca
JR
336 for(i=0; i<s->fbw_channels; i++) {
337 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
338 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
3bbb0bf8 339 }
d802d7ca 340 if(s->channel_mode > 1 && s->channel_mode & 1) {
f0b3a7ba 341 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
3bbb0bf8 342 }
d802d7ca
JR
343 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
344 int nf = s->channel_mode - 2;
f0b3a7ba 345 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
3bbb0bf8 346 }
d802d7ca
JR
347 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
348 int nf = s->channel_mode - 4;
f0b3a7ba 349 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
3bbb0bf8 350 }
9d10e6e6 351
557ac0c4
LM
352 /* renormalize */
353 norm0 = norm1 = 0.0;
9d10e6e6 354 for(i=0; i<s->fbw_channels; i++) {
557ac0c4
LM
355 norm0 += s->downmix_coeffs[i][0];
356 norm1 += s->downmix_coeffs[i][1];
357 }
358 norm0 = 1.0f / norm0;
359 norm1 = 1.0f / norm1;
360 for(i=0; i<s->fbw_channels; i++) {
361 s->downmix_coeffs[i][0] *= norm0;
362 s->downmix_coeffs[i][1] *= norm1;
363 }
364
365 if(s->output_mode == AC3_CHMODE_MONO) {
366 for(i=0; i<s->fbw_channels; i++)
367 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
9d10e6e6 368 }
2aa2c5c4
JR
369}
370
3bb004fc 371/**
5066f515
JR
372 * Decode the grouped exponents according to exponent strategy.
373 * reference: Section 7.1.3 Exponent Decoding
2aa2c5c4 374 */
23c8cb89 375static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
bc8edb7e 376 uint8_t absexp, int8_t *dexps)
2aa2c5c4 377{
e2270b4e 378 int i, j, grp, group_size;
4415076f
JR
379 int dexp[256];
380 int expacc, prevexp;
381
382 /* unpack groups */
e2270b4e 383 group_size = exp_strategy + (exp_strategy == EXP_D45);
4415076f 384 for(grp=0,i=0; grp<ngrps; grp++) {
23c8cb89 385 expacc = get_bits(gbc, 7);
7417120b
JR
386 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
387 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
388 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
4415076f 389 }
2aa2c5c4 390
4415076f
JR
391 /* convert to absolute exps and expand groups */
392 prevexp = absexp;
393 for(i=0; i<ngrps*3; i++) {
394 prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
e2270b4e
JR
395 for(j=0; j<group_size; j++) {
396 dexps[(i*group_size)+j] = prevexp;
1b293437 397 }
2aa2c5c4 398 }
2aa2c5c4
JR
399}
400
d7dc7ad0 401/**
5066f515 402 * Generate transform coefficients for each coupled channel in the coupling
d7dc7ad0
JR
403 * range using the coupling coefficients and coupling coordinates.
404 * reference: Section 7.4.3 Coupling Coordinate Format
405 */
5e3e4075 406static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
d7dc7ad0
JR
407{
408 int i, j, ch, bnd, subbnd;
409
410 subbnd = -1;
d802d7ca
JR
411 i = s->start_freq[CPL_CH];
412 for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
d7dc7ad0
JR
413 do {
414 subbnd++;
415 for(j=0; j<12; j++) {
d802d7ca 416 for(ch=1; ch<=s->fbw_channels; ch++) {
b02fbf75 417 if(s->channel_in_cpl[ch]) {
a4de6dd2 418 s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
b02fbf75 419 if (ch == 2 && s->phase_flags[bnd])
a4de6dd2 420 s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
b02fbf75 421 }
d7dc7ad0
JR
422 }
423 i++;
424 }
d802d7ca 425 } while(s->cpl_band_struct[subbnd]);
d7dc7ad0
JR
426 }
427}
428
5066f515
JR
429/**
430 * Grouped mantissas for 3-level 5-level and 11-level quantization
431 */
432typedef struct {
a4de6dd2
JR
433 int b1_mant[3];
434 int b2_mant[3];
435 int b4_mant[2];
5aefe3eb
JR
436 int b1ptr;
437 int b2ptr;
438 int b4ptr;
486637af
JR
439} mant_groups;
440
5066f515 441/**
e522bd49 442 * Decode the transform coefficients for a particular channel
5066f515
JR
443 * reference: Section 7.3 Quantization and Decoding of Mantissas
444 */
e43b29ab 445static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
1b293437 446{
d802d7ca 447 GetBitContext *gbc = &s->gbc;
60f07fad 448 int i, gcode, tbap, start, end;
2fbbd087
JR
449 uint8_t *exps;
450 uint8_t *bap;
a4de6dd2 451 int *coeffs;
2fbbd087 452
d802d7ca
JR
453 exps = s->dexps[ch_index];
454 bap = s->bap[ch_index];
a4de6dd2 455 coeffs = s->fixed_coeffs[ch_index];
d802d7ca
JR
456 start = s->start_freq[ch_index];
457 end = s->end_freq[ch_index];
1b293437 458
285bf28c 459 for (i = start; i < end; i++) {
98a27a8a
JR
460 tbap = bap[i];
461 switch (tbap) {
1b293437 462 case 0:
ec0350c9 463 coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
d63f6fea 464 break;
1b293437
JR
465
466 case 1:
5aefe3eb 467 if(m->b1ptr > 2) {
23c8cb89 468 gcode = get_bits(gbc, 5);
5aefe3eb
JR
469 m->b1_mant[0] = b1_mantissas[gcode][0];
470 m->b1_mant[1] = b1_mantissas[gcode][1];
471 m->b1_mant[2] = b1_mantissas[gcode][2];
472 m->b1ptr = 0;
1b293437 473 }
5aefe3eb 474 coeffs[i] = m->b1_mant[m->b1ptr++];
d63f6fea 475 break;
1b293437
JR
476
477 case 2:
5aefe3eb 478 if(m->b2ptr > 2) {
23c8cb89 479 gcode = get_bits(gbc, 7);
5aefe3eb
JR
480 m->b2_mant[0] = b2_mantissas[gcode][0];
481 m->b2_mant[1] = b2_mantissas[gcode][1];
482 m->b2_mant[2] = b2_mantissas[gcode][2];
483 m->b2ptr = 0;
1b293437 484 }
5aefe3eb 485 coeffs[i] = m->b2_mant[m->b2ptr++];
d63f6fea 486 break;
1b293437
JR
487
488 case 3:
23c8cb89 489 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
d63f6fea 490 break;
1b293437
JR
491
492 case 4:
5aefe3eb 493 if(m->b4ptr > 1) {
23c8cb89 494 gcode = get_bits(gbc, 7);
5aefe3eb
JR
495 m->b4_mant[0] = b4_mantissas[gcode][0];
496 m->b4_mant[1] = b4_mantissas[gcode][1];
497 m->b4ptr = 0;
1b293437 498 }
5aefe3eb 499 coeffs[i] = m->b4_mant[m->b4ptr++];
d63f6fea 500 break;
1b293437
JR
501
502 case 5:
23c8cb89 503 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
d63f6fea 504 break;
1b293437 505
a4de6dd2 506 default: {
5066f515 507 /* asymmetric dequantization */
a4de6dd2
JR
508 int qlevel = quantization_tab[tbap];
509 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
d63f6fea 510 break;
a4de6dd2 511 }
1b293437 512 }
a4de6dd2 513 coeffs[i] >>= exps[i];
1b293437 514 }
1b293437
JR
515}
516
60f07fad 517/**
5066f515 518 * Remove random dithering from coefficients with zero-bit mantissas
60f07fad
JR
519 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
520 */
d802d7ca 521static void remove_dithering(AC3DecodeContext *s) {
60f07fad
JR
522 int ch, i;
523 int end=0;
a4de6dd2 524 int *coeffs;
60f07fad
JR
525 uint8_t *bap;
526
d802d7ca
JR
527 for(ch=1; ch<=s->fbw_channels; ch++) {
528 if(!s->dither_flag[ch]) {
a4de6dd2 529 coeffs = s->fixed_coeffs[ch];
d802d7ca
JR
530 bap = s->bap[ch];
531 if(s->channel_in_cpl[ch])
532 end = s->start_freq[CPL_CH];
60f07fad 533 else
d802d7ca 534 end = s->end_freq[ch];
60f07fad 535 for(i=0; i<end; i++) {
12eaa3b7 536 if(!bap[i])
a4de6dd2 537 coeffs[i] = 0;
60f07fad 538 }
d802d7ca
JR
539 if(s->channel_in_cpl[ch]) {
540 bap = s->bap[CPL_CH];
541 for(; i<s->end_freq[CPL_CH]; i++) {
12eaa3b7 542 if(!bap[i])
a4de6dd2 543 coeffs[i] = 0;
60f07fad
JR
544 }
545 }
546 }
547 }
548}
549
6a68105e 550static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
bf09b550
JR
551 mant_groups *m)
552{
553 if (!s->channel_uses_aht[ch]) {
6a68105e 554 ac3_decode_transform_coeffs_ch(s, ch, m);
bf09b550
JR
555 } else {
556 /* if AHT is used, mantissas for all blocks are encoded in the first
557 block of the frame. */
558 int bin;
559 if (!blk)
6a68105e 560 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
bf09b550
JR
561 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
562 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
563 }
564 }
565}
bf09b550 566
5066f515 567/**
164e169f 568 * Decode the transform coefficients.
c7cfc48f 569 */
e43b29ab 570static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
1b293437 571{
7b4076a7 572 int ch, end;
1b293437 573 int got_cplchan = 0;
486637af
JR
574 mant_groups m;
575
5aefe3eb 576 m.b1ptr = m.b2ptr = m.b4ptr = 3;
1b293437 577
d802d7ca 578 for (ch = 1; ch <= s->channels; ch++) {
5066f515 579 /* transform coefficients for full-bandwidth channel */
e43b29ab 580 decode_transform_coeffs_ch(s, blk, ch, &m);
5066f515
JR
581 /* tranform coefficients for coupling channel come right after the
582 coefficients for the first coupled channel*/
d802d7ca 583 if (s->channel_in_cpl[ch]) {
486637af 584 if (!got_cplchan) {
e43b29ab 585 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
5e3e4075 586 calc_transform_coeffs_cpl(s);
486637af
JR
587 got_cplchan = 1;
588 }
d802d7ca 589 end = s->end_freq[CPL_CH];
eaf84d97 590 } else {
d802d7ca 591 end = s->end_freq[ch];
eaf84d97 592 }
486637af 593 do
bd98e9e2 594 s->fixed_coeffs[ch][end] = 0;
486637af
JR
595 while(++end < 256);
596 }
1b293437 597
ea364c74 598 /* zero the dithered coefficients for appropriate channels */
86662b1c 599 remove_dithering(s);
2aa2c5c4
JR
600}
601
8b60bbbf 602/**
5066f515 603 * Stereo rematrixing.
8b60bbbf
JR
604 * reference: Section 7.5.4 Rematrixing : Decoding Technique
605 */
d802d7ca 606static void do_rematrixing(AC3DecodeContext *s)
1b293437 607{
8b60bbbf 608 int bnd, i;
2fbbd087 609 int end, bndend;
a4de6dd2 610 int tmp0, tmp1;
2fbbd087 611
d802d7ca 612 end = FFMIN(s->end_freq[1], s->end_freq[2]);
1b293437 613
d802d7ca
JR
614 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
615 if(s->rematrixing_flags[bnd]) {
227322b8
JR
616 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
617 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
a4de6dd2
JR
618 tmp0 = s->fixed_coeffs[1][i];
619 tmp1 = s->fixed_coeffs[2][i];
620 s->fixed_coeffs[1][i] = tmp0 + tmp1;
621 s->fixed_coeffs[2][i] = tmp0 - tmp1;
8b60bbbf
JR
622 }
623 }
1b293437
JR
624 }
625}
2aa2c5c4 626
5066f515 627/**
5066f515
JR
628 * Inverse MDCT Transform.
629 * Convert frequency domain coefficients to time-domain audio samples.
630 * reference: Section 7.9.4 Transformation Equations
631 */
38dae9c3 632static inline void do_imdct(AC3DecodeContext *s, int channels)
486637af 633{
0de73a46 634 int ch;
3b6516f7
LM
635 float add_bias = s->add_bias;
636 if(s->out_channels==1 && channels>1)
637 add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
7b4076a7 638
e2270b4e 639 for (ch=1; ch<=channels; ch++) {
d802d7ca 640 if (s->block_switch[ch]) {
916d5d6c
LM
641 int i;
642 float *x = s->tmp_output+128;
643 for(i=0; i<128; i++)
644 x[i] = s->transform_coeffs[ch][2*i];
645 ff_imdct_half(&s->imdct_256, s->tmp_output, x);
3b6516f7 646 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
916d5d6c
LM
647 for(i=0; i<128; i++)
648 x[i] = s->transform_coeffs[ch][2*i+1];
649 ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
eaf84d97 650 } else {
916d5d6c 651 ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
3b6516f7 652 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
916d5d6c 653 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
eaf84d97 654 }
486637af
JR
655 }
656}
657
3bbb0bf8 658/**
5066f515 659 * Downmix the output to mono or stereo.
3bbb0bf8 660 */
ac2e5564 661void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
3bbb0bf8
JR
662{
663 int i, j;
9d10e6e6 664 float v0, v1;
ac2e5564
LM
665 if(out_ch == 2) {
666 for(i=0; i<len; i++) {
557ac0c4 667 v0 = v1 = 0.0f;
ac2e5564
LM
668 for(j=0; j<in_ch; j++) {
669 v0 += samples[j][i] * matrix[j][0];
670 v1 += samples[j][i] * matrix[j][1];
557ac0c4
LM
671 }
672 samples[0][i] = v0;
673 samples[1][i] = v1;
3bbb0bf8 674 }
ac2e5564
LM
675 } else if(out_ch == 1) {
676 for(i=0; i<len; i++) {
557ac0c4 677 v0 = 0.0f;
ac2e5564
LM
678 for(j=0; j<in_ch; j++)
679 v0 += samples[j][i] * matrix[j][0];
557ac0c4 680 samples[0][i] = v0;
3bbb0bf8
JR
681 }
682 }
683}
684
5066f515 685/**
38dae9c3
JR
686 * Upmix delay samples from stereo to original channel layout.
687 */
688static void ac3_upmix_delay(AC3DecodeContext *s)
689{
e6300276 690 int channel_data_size = sizeof(s->delay[0]);
38dae9c3
JR
691 switch(s->channel_mode) {
692 case AC3_CHMODE_DUALMONO:
693 case AC3_CHMODE_STEREO:
694 /* upmix mono to stereo */
695 memcpy(s->delay[1], s->delay[0], channel_data_size);
696 break;
697 case AC3_CHMODE_2F2R:
698 memset(s->delay[3], 0, channel_data_size);
699 case AC3_CHMODE_2F1R:
700 memset(s->delay[2], 0, channel_data_size);
701 break;
702 case AC3_CHMODE_3F2R:
703 memset(s->delay[4], 0, channel_data_size);
704 case AC3_CHMODE_3F1R:
705 memset(s->delay[3], 0, channel_data_size);
706 case AC3_CHMODE_3F:
707 memcpy(s->delay[2], s->delay[1], channel_data_size);
708 memset(s->delay[1], 0, channel_data_size);
709 break;
710 }
711}
712
713/**
022845ed 714 * Decode a single audio block from the AC-3 bitstream.
c7cfc48f 715 */
022845ed 716static int decode_audio_block(AC3DecodeContext *s, int blk)
2aa2c5c4 717{
d802d7ca
JR
718 int fbw_channels = s->fbw_channels;
719 int channel_mode = s->channel_mode;
0bff58a5 720 int i, bnd, seg, ch;
38dae9c3
JR
721 int different_transforms;
722 int downmix_output;
54624396 723 int cpl_in_use;
d802d7ca 724 GetBitContext *gbc = &s->gbc;
7b4076a7 725 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
1b293437 726
7b4076a7
JR
727 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
728
5066f515 729 /* block switch flags */
38dae9c3 730 different_transforms = 0;
bf09b550 731 if (s->block_switch_syntax) {
ab2a942a
JR
732 for (ch = 1; ch <= fbw_channels; ch++) {
733 s->block_switch[ch] = get_bits1(gbc);
734 if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
735 different_transforms = 1;
736 }
bf09b550 737 }
98a27a8a 738
5066f515 739 /* dithering flags */
bf09b550 740 if (s->dither_flag_syntax) {
ab2a942a
JR
741 for (ch = 1; ch <= fbw_channels; ch++) {
742 s->dither_flag[ch] = get_bits1(gbc);
ab2a942a 743 }
bf09b550 744 }
98a27a8a 745
77416325 746 /* dynamic range */
d802d7ca 747 i = !(s->channel_mode);
77416325 748 do {
23c8cb89 749 if(get_bits1(gbc)) {
d802d7ca 750 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
1b70d88b 751 s->avctx->drc_scale)+1.0;
9fc1ab72 752 } else if(blk == 0) {
d802d7ca 753 s->dynamic_range[i] = 1.0f;
9fc1ab72 754 }
77416325 755 } while(i--);
98a27a8a 756
6fafb020
JR
757 /* spectral extension strategy */
758 if (s->eac3 && (!blk || get_bits1(gbc))) {
759 if (get_bits1(gbc)) {
760 av_log_missing_feature(s->avctx, "Spectral extension", 1);
761 return -1;
762 }
763 /* TODO: parse spectral extension strategy info */
764 }
765
766 /* TODO: spectral extension coordinates */
767
5066f515 768 /* coupling strategy */
225c3042 769 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
7b4076a7 770 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
6fafb020 771 if (!s->eac3)
0569993e 772 s->cpl_in_use[blk] = get_bits1(gbc);
4760aec6 773 if (s->cpl_in_use[blk]) {
5066f515 774 /* coupling in use */
24834c19 775 int cpl_start_subband, cpl_end_subband;
b6acc57f 776
3af91313
JR
777 if (channel_mode < AC3_CHMODE_STEREO) {
778 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
779 return -1;
780 }
781
6fafb020
JR
782 /* check for enhanced coupling */
783 if (s->eac3 && get_bits1(gbc)) {
784 /* TODO: parse enhanced coupling strategy info */
785 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
786 return -1;
787 }
788
5066f515 789 /* determine which channels are coupled */
6fafb020
JR
790 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
791 s->channel_in_cpl[1] = 1;
792 s->channel_in_cpl[2] = 1;
793 } else {
0569993e
JR
794 for (ch = 1; ch <= fbw_channels; ch++)
795 s->channel_in_cpl[ch] = get_bits1(gbc);
6fafb020 796 }
98a27a8a 797
5066f515 798 /* phase flags in use */
e59cc205 799 if (channel_mode == AC3_CHMODE_STEREO)
d802d7ca 800 s->phase_flags_in_use = get_bits1(gbc);
98a27a8a 801
6fafb020
JR
802 /* coupling frequency range */
803 /* TODO: modify coupling end freq if spectral extension is used */
24834c19 804 cpl_start_subband = get_bits(gbc, 4);
6ee6d068
JR
805 cpl_end_subband = get_bits(gbc, 4) + 3;
806 s->num_cpl_subbands = cpl_end_subband - cpl_start_subband;
807 if (s->num_cpl_subbands < 0) {
808 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d > %d)\n",
809 cpl_start_subband, cpl_end_subband);
00585845 810 return -1;
98a27a8a 811 }
24834c19 812 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
6ee6d068 813 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
6fafb020
JR
814
815 /* coupling band structure */
6ee6d068 816 s->num_cpl_bands = s->num_cpl_subbands;
6fafb020 817 if (!s->eac3 || get_bits1(gbc)) {
0569993e 818 for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
6fafb020 819 s->cpl_band_struct[bnd] = get_bits1(gbc);
1b293437 820 }
6fafb020 821 } else if (!blk) {
0ffea243 822 memcpy(s->cpl_band_struct,
24834c19 823 &ff_eac3_default_cpl_band_struct[cpl_start_subband+1],
0ffea243 824 s->num_cpl_subbands-1);
eaf84d97 825 }
4bc829bb 826 s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
6fafb020
JR
827
828 /* calculate number of coupling bands based on band structure */
829 for (bnd = 0; bnd < s->num_cpl_subbands-1; bnd++) {
830 s->num_cpl_bands -= s->cpl_band_struct[bnd];
831 }
878c40a1 832 } else {
5066f515 833 /* coupling not in use */
6fafb020 834 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 835 s->channel_in_cpl[ch] = 0;
6fafb020
JR
836 s->first_cpl_coords[ch] = 1;
837 }
63d72fb1 838 s->first_cpl_leak = s->eac3;
6fafb020 839 s->phase_flags_in_use = 0;
1b293437 840 }
6fafb020
JR
841 } else if (!s->eac3) {
842 if(!blk) {
0569993e
JR
843 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
844 return -1;
845 } else {
846 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
847 }
6fafb020 848 }
4760aec6 849 cpl_in_use = s->cpl_in_use[blk];
98a27a8a 850
5066f515 851 /* coupling coordinates */
54624396 852 if (cpl_in_use) {
e2270b4e 853 int cpl_coords_exist = 0;
98a27a8a 854
e2270b4e 855 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 856 if (s->channel_in_cpl[ch]) {
225c3042 857 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
e2270b4e 858 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
225c3042 859 s->first_cpl_coords[ch] = 0;
e2270b4e 860 cpl_coords_exist = 1;
23c8cb89 861 master_cpl_coord = 3 * get_bits(gbc, 2);
d802d7ca 862 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
23c8cb89
JR
863 cpl_coord_exp = get_bits(gbc, 4);
864 cpl_coord_mant = get_bits(gbc, 4);
e2270b4e 865 if (cpl_coord_exp == 15)
a4de6dd2 866 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
486637af 867 else
a4de6dd2
JR
868 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
869 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
486637af 870 }
82a591d8
JR
871 } else if (!blk) {
872 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
873 return -1;
486637af 874 }
225c3042
JR
875 } else {
876 /* channel not in coupling */
877 s->first_cpl_coords[ch] = 1;
eaf84d97
JR
878 }
879 }
5066f515 880 /* phase flags */
b02fbf75 881 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
d802d7ca 882 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
b02fbf75 883 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
eaf84d97
JR
884 }
885 }
2aa2c5c4 886 }
98a27a8a 887
5066f515 888 /* stereo rematrixing strategy and band structure */
e59cc205 889 if (channel_mode == AC3_CHMODE_STEREO) {
6fafb020 890 if ((s->eac3 && !blk) || get_bits1(gbc)) {
d802d7ca 891 s->num_rematrixing_bands = 4;
54624396 892 if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
d802d7ca
JR
893 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
894 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
895 s->rematrixing_flags[bnd] = get_bits1(gbc);
82a591d8
JR
896 } else if (!blk) {
897 av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
898 return -1;
1b293437 899 }
98a27a8a
JR
900 }
901
5066f515 902 /* exponent strategies for each channel */
54624396 903 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
6b4bfed9 904 if (!s->eac3)
aec0407f 905 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
da04be10 906 if(s->exp_strategy[blk][ch] != EXP_REUSE)
7b4076a7
JR
907 bit_alloc_stages[ch] = 3;
908 }
909
5066f515 910 /* channel bandwidth */
e2270b4e 911 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 912 s->start_freq[ch] = 0;
da04be10 913 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
b85a15fe 914 int group_size;
d802d7ca
JR
915 int prev = s->end_freq[ch];
916 if (s->channel_in_cpl[ch])
917 s->end_freq[ch] = s->start_freq[CPL_CH];
00585845 918 else {
23c8cb89 919 int bandwidth_code = get_bits(gbc, 6);
e2270b4e 920 if (bandwidth_code > 60) {
6c6f9272 921 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
00585845
JR
922 return -1;
923 }
d802d7ca 924 s->end_freq[ch] = bandwidth_code * 3 + 73;
1b293437 925 }
da04be10 926 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
b85a15fe 927 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
d802d7ca 928 if(blk > 0 && s->end_freq[ch] != prev)
7b4076a7 929 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00585845 930 }
eaf84d97 931 }
da04be10 932 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
b85a15fe 933 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
da04be10 934 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
b85a15fe 935 }
7b4076a7 936
5066f515 937 /* decode exponents for each channel */
54624396 938 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
da04be10 939 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
d802d7ca 940 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
da04be10 941 decode_exponents(gbc, s->exp_strategy[blk][ch],
b85a15fe 942 s->num_exp_groups[ch], s->dexps[ch][0],
d802d7ca
JR
943 &s->dexps[ch][s->start_freq[ch]+!!ch]);
944 if(ch != CPL_CH && ch != s->lfe_ch)
23c8cb89 945 skip_bits(gbc, 2); /* skip gainrng */
1b293437 946 }
eaf84d97 947 }
98a27a8a 948
5066f515 949 /* bit allocation information */
bf09b550 950 if (s->bit_allocation_syntax) {
ab2a942a
JR
951 if (get_bits1(gbc)) {
952 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
953 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
954 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
955 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
956 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
957 for(ch=!cpl_in_use; ch<=s->channels; ch++)
958 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
959 } else if (!blk) {
960 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
961 return -1;
962 }
bf09b550 963 }
98a27a8a 964
5066f515 965 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
8dfc56ec
JR
966 if(!s->eac3 || !blk){
967 if(s->snr_offset_strategy && get_bits1(gbc)) {
f2e4eb62
JR
968 int snr = 0;
969 int csnr;
970 csnr = (get_bits(gbc, 6) - 15) << 4;
971 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
972 /* snr offset */
973 if (ch == i || s->snr_offset_strategy == 2)
974 snr = (csnr + get_bits(gbc, 4)) << 2;
975 /* run at least last bit allocation stage if snr offset changes */
976 if(blk && s->snr_offset[ch] != snr) {
977 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
978 }
979 s->snr_offset[ch] = snr;
8dfc56ec
JR
980
981 /* fast gain (normal AC-3 only) */
982 if (!s->eac3) {
983 int prev = s->fast_gain[ch];
f2e4eb62 984 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
8dfc56ec
JR
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);
8dfc56ec 988 }
f2e4eb62 989 }
8dfc56ec 990 } else if (!s->eac3 && !blk) {
f2e4eb62
JR
991 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
992 return -1;
8dfc56ec 993 }
1b293437 994 }
98a27a8a 995
6fafb020
JR
996 /* fast gain (E-AC-3 only) */
997 if (s->fast_gain_syntax && get_bits1(gbc)) {
998 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
999 int prev = s->fast_gain[ch];
1000 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1001 /* run last 2 bit allocation stages if fast gain changes */
1002 if(blk && prev != s->fast_gain[ch])
1003 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1004 }
1005 } else if (s->eac3 && !blk) {
1006 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1007 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1008 }
1009
1010 /* E-AC-3 to AC-3 converter SNR offset */
1011 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1012 skip_bits(gbc, 10); // skip converter snr offset
1013 }
1014
5066f515 1015 /* coupling leak information */
54624396 1016 if (cpl_in_use) {
8dfc56ec
JR
1017 if (s->first_cpl_leak || get_bits1(gbc)) {
1018 int fl = get_bits(gbc, 3);
1019 int sl = get_bits(gbc, 3);
1020 /* run last 2 bit allocation stages for coupling channel if
1021 coupling leak changes */
1022 if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1023 sl != s->bit_alloc_params.cpl_slow_leak)) {
f2e4eb62 1024 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
8dfc56ec
JR
1025 }
1026 s->bit_alloc_params.cpl_fast_leak = fl;
1027 s->bit_alloc_params.cpl_slow_leak = sl;
1028 } else if (!s->eac3 && !blk) {
93a2c8c1
JR
1029 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1030 return -1;
1031 }
8dfc56ec 1032 s->first_cpl_leak = 0;
43ad93a4 1033 }
98a27a8a 1034
5066f515 1035 /* delta bit allocation information */
bf09b550 1036 if (s->dba_syntax && get_bits1(gbc)) {
5066f515 1037 /* delta bit allocation exists (strategy) */
54624396 1038 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca
JR
1039 s->dba_mode[ch] = get_bits(gbc, 2);
1040 if (s->dba_mode[ch] == DBA_RESERVED) {
1041 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1b293437
JR
1042 return -1;
1043 }
7b4076a7 1044 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1045 }
5066f515 1046 /* channel delta offset, len and bit allocation */
54624396 1047 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca
JR
1048 if (s->dba_mode[ch] == DBA_NEW) {
1049 s->dba_nsegs[ch] = get_bits(gbc, 3);
1050 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1051 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1052 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1053 s->dba_values[ch][seg] = get_bits(gbc, 3);
1b293437 1054 }
e25973a1
JR
1055 /* run last 2 bit allocation stages if new dba values */
1056 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1057 }
eaf84d97 1058 }
9fc1ab72 1059 } else if(blk == 0) {
d802d7ca
JR
1060 for(ch=0; ch<=s->channels; ch++) {
1061 s->dba_mode[ch] = DBA_NONE;
9fc1ab72 1062 }
1b293437 1063 }
00585845 1064
5066f515 1065 /* Bit allocation */
54624396 1066 for(ch=!cpl_in_use; ch<=s->channels; ch++) {
7b4076a7
JR
1067 if(bit_alloc_stages[ch] > 2) {
1068 /* Exponent mapping into PSD and PSD integration */
d802d7ca
JR
1069 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1070 s->start_freq[ch], s->end_freq[ch],
1071 s->psd[ch], s->band_psd[ch]);
eaf84d97 1072 }
7b4076a7
JR
1073 if(bit_alloc_stages[ch] > 1) {
1074 /* Compute excitation function, Compute masking curve, and
1075 Apply delta bit allocation */
d802d7ca
JR
1076 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1077 s->start_freq[ch], s->end_freq[ch],
1078 s->fast_gain[ch], (ch == s->lfe_ch),
1079 s->dba_mode[ch], s->dba_nsegs[ch],
1080 s->dba_offsets[ch], s->dba_lengths[ch],
1081 s->dba_values[ch], s->mask[ch]);
eaf84d97 1082 }
7b4076a7
JR
1083 if(bit_alloc_stages[ch] > 0) {
1084 /* Compute bit allocation */
bf09b550
JR
1085 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1086 ff_eac3_hebap_tab : ff_ac3_bap_tab;
d802d7ca
JR
1087 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1088 s->start_freq[ch], s->end_freq[ch],
1089 s->snr_offset[ch],
1090 s->bit_alloc_params.floor,
bf09b550 1091 bap_tab, s->bap[ch]);
eaf84d97 1092 }
2fbbd087 1093 }
98a27a8a 1094
5066f515 1095 /* unused dummy data */
bf09b550 1096 if (s->skip_syntax && get_bits1(gbc)) {
23c8cb89 1097 int skipl = get_bits(gbc, 9);
98a27a8a 1098 while(skipl--)
23c8cb89 1099 skip_bits(gbc, 8);
1b293437 1100 }
f5cefb21 1101
1b293437 1102 /* unpack the transform coefficients
5066f515 1103 this also uncouples channels if coupling is in use. */
e43b29ab 1104 decode_transform_coeffs(s, blk);
486637af 1105
bf09b550
JR
1106 /* TODO: generate enhanced coupling coordinates and uncouple */
1107
1108 /* TODO: apply spectral extension */
1109
1b293437 1110 /* recover coefficients if rematrixing is in use */
d802d7ca
JR
1111 if(s->channel_mode == AC3_CHMODE_STEREO)
1112 do_rematrixing(s);
1b293437 1113
03726b70 1114 /* apply scaling to coefficients (headroom, dynrng) */
d802d7ca 1115 for(ch=1; ch<=s->channels; ch++) {
a4de6dd2 1116 float gain = s->mul_bias / 4194304.0f;
d802d7ca
JR
1117 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1118 gain *= s->dynamic_range[ch-1];
7bfd22f2 1119 } else {
d802d7ca 1120 gain *= s->dynamic_range[0];
7bfd22f2 1121 }
911e21a3 1122 s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
7bfd22f2 1123 }
d7bcc4ad 1124
38dae9c3
JR
1125 /* downmix and MDCT. order depends on whether block switching is used for
1126 any channel in this block. this is because coefficients for the long
1127 and short transforms cannot be mixed. */
1128 downmix_output = s->channels != s->out_channels &&
1129 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1130 s->fbw_channels == s->out_channels);
1131 if(different_transforms) {
1132 /* the delay samples have already been downmixed, so we upmix the delay
1133 samples in order to reconstruct all channels before downmixing. */
1134 if(s->downmixed) {
1135 s->downmixed = 0;
1136 ac3_upmix_delay(s);
1137 }
1138
1139 do_imdct(s, s->channels);
1140
1141 if(downmix_output) {
ac2e5564 1142 s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
38dae9c3
JR
1143 }
1144 } else {
1145 if(downmix_output) {
ac2e5564 1146 s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
38dae9c3
JR
1147 }
1148
45d9d618 1149 if(downmix_output && !s->downmixed) {
38dae9c3 1150 s->downmixed = 1;
ac2e5564 1151 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
38dae9c3 1152 }
486637af 1153
38dae9c3 1154 do_imdct(s, s->out_channels);
3bbb0bf8
JR
1155 }
1156
4e092320 1157 return 0;
486637af
JR
1158}
1159
5066f515
JR
1160/**
1161 * Decode a single AC-3 frame.
c7cfc48f 1162 */
98f6dfa6
JR
1163static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1164 const uint8_t *buf, int buf_size)
1b293437 1165{
0345fade 1166 AC3DecodeContext *s = avctx->priv_data;
00585845 1167 int16_t *out_samples = (int16_t *)data;
72745cff 1168 int blk, ch, err;
d7bcc4ad 1169
5066f515 1170 /* initialize the GetBitContext with the start of valid AC-3 Frame */
509fdb0b 1171 if (s->input_buffer) {
c33a1967
JR
1172 /* copy input buffer to decoder context to avoid reading past the end
1173 of the buffer, which can be caused by a damaged input stream. */
8e33132b 1174 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
c33a1967
JR
1175 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1176 } else {
984ff38a 1177 init_get_bits(&s->gbc, buf, buf_size * 8);
c33a1967 1178 }
00585845 1179
5066f515 1180 /* parse the syncinfo */
c78c6d6c 1181 *data_size = 0;
4397d95c 1182 err = parse_frame_header(s);
c78c6d6c
JR
1183
1184 /* check that reported frame size fits in input buffer */
1185 if(s->frame_size > buf_size) {
1186 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1187 err = AC3_PARSE_ERROR_FRAME_SIZE;
1188 }
1189
1190 /* check for crc mismatch */
047599a4 1191 if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
c78c6d6c
JR
1192 if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1193 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
fbe52e41 1194 err = AC3_PARSE_ERROR_CRC;
c78c6d6c
JR
1195 }
1196 }
1197
fbe52e41 1198 if(err && err != AC3_PARSE_ERROR_CRC) {
3df88093
JR
1199 switch(err) {
1200 case AC3_PARSE_ERROR_SYNC:
c78c6d6c 1201 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
7af26d14 1202 return -1;
3df88093
JR
1203 case AC3_PARSE_ERROR_BSID:
1204 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1205 break;
1206 case AC3_PARSE_ERROR_SAMPLE_RATE:
1207 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1208 break;
1209 case AC3_PARSE_ERROR_FRAME_SIZE:
1210 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1211 break;
79b25a27 1212 case AC3_PARSE_ERROR_FRAME_TYPE:
aa5d6be8
JR
1213 /* skip frame if CRC is ok. otherwise use error concealment. */
1214 /* TODO: add support for substreams and dependent frames */
1215 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1216 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1217 return s->frame_size;
1218 } else {
4921bbba 1219 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
aa5d6be8 1220 }
4e6eeaf0 1221 break;
3df88093
JR
1222 default:
1223 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1224 break;
1225 }
1b293437 1226 }
2aa2c5c4 1227
eccba2bc
JR
1228 /* if frame is ok, set audio parameters */
1229 if (!err) {
3336110a
JR
1230 avctx->sample_rate = s->sample_rate;
1231 avctx->bit_rate = s->bit_rate;
1232
1233 /* channel config */
1234 s->out_channels = s->channels;
eccba2bc
JR
1235 s->output_mode = s->channel_mode;
1236 if(s->lfe_on)
1237 s->output_mode |= AC3_OUTPUT_LFEON;
3336110a
JR
1238 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1239 avctx->request_channels < s->channels) {
1240 s->out_channels = avctx->request_channels;
1241 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1242 }
1243 avctx->channels = s->out_channels;
1b293437 1244
3336110a
JR
1245 /* set downmixing coefficients if needed */
1246 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1247 s->fbw_channels == s->out_channels)) {
1248 set_downmix_coeffs(s);
1249 }
eccba2bc
JR
1250 } else if (!s->out_channels) {
1251 s->out_channels = avctx->channels;
1252 if(s->out_channels < s->channels)
1253 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
ecfe94b2 1254 }
f0b3a7ba 1255
022845ed 1256 /* decode the audio blocks */
6730e9f3 1257 for (blk = 0; blk < s->num_blocks; blk++) {
72745cff 1258 const float *output[s->out_channels];
022845ed
JR
1259 if (!err && decode_audio_block(s, blk)) {
1260 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1b293437 1261 }
72745cff
LM
1262 for (ch = 0; ch < s->out_channels; ch++)
1263 output[ch] = s->output[ch];
1264 s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1265 out_samples += 256 * s->out_channels;
1b293437 1266 }
6730e9f3 1267 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
d802d7ca 1268 return s->frame_size;
2aa2c5c4 1269}
1b293437 1270
5066f515
JR
1271/**
1272 * Uninitialize the AC-3 decoder.
c7cfc48f 1273 */
98a6fff9 1274static av_cold int ac3_decode_end(AVCodecContext *avctx)
1b293437 1275{
0345fade 1276 AC3DecodeContext *s = avctx->priv_data;
d802d7ca
JR
1277 ff_mdct_end(&s->imdct_512);
1278 ff_mdct_end(&s->imdct_256);
c7cfc48f 1279
509fdb0b
JR
1280 av_freep(&s->input_buffer);
1281
1b293437
JR
1282 return 0;
1283}
1284
fa67992d 1285AVCodec ac3_decoder = {
e6bca37c
JR
1286 .name = "ac3",
1287 .type = CODEC_TYPE_AUDIO,
1288 .id = CODEC_ID_AC3,
1289 .priv_data_size = sizeof (AC3DecodeContext),
1290 .init = ac3_decode_init,
1291 .close = ac3_decode_end,
1292 .decode = ac3_decode_frame,
2988c93d
JR
1293 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1294};
1295
1296AVCodec eac3_decoder = {
1297 .name = "eac3",
1298 .type = CODEC_TYPE_AUDIO,
1299 .id = CODEC_ID_EAC3,
1300 .priv_data_size = sizeof (AC3DecodeContext),
1301 .init = ac3_decode_init,
1302 .close = ac3_decode_end,
1303 .decode = ac3_decode_frame,
1304 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1b293437 1305};