ac3dec: make drc_scale exponentially
[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 *
406792e7 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 *
2912e87a 10 * This file is part of Libav.
2aa2c5c4 11 *
2912e87a 12 * Libav is free software; you can redistribute it and/or
1754fe4d 13 * modify it under the terms of the GNU Lesser General Public
2aa2c5c4 14 * License as published by the Free Software Foundation; either
1754fe4d 15 * version 2.1 of the License, or (at your option) any later version.
2aa2c5c4 16 *
2912e87a 17 * Libav is distributed in the hope that it will be useful,
2aa2c5c4
JR
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1754fe4d 20 * Lesser General Public License for more details.
2aa2c5c4 21 *
1754fe4d 22 * You should have received a copy of the GNU Lesser General Public
2912e87a 23 * License along with Libav; if not, write to the Free Software
2aa2c5c4
JR
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 */
26
27#include <stdio.h>
28#include <stddef.h>
29#include <math.h>
2aa2c5c4
JR
30#include <string.h>
31
b5328546 32#include "libavutil/channel_layout.h"
245976da 33#include "libavutil/crc.h"
9b83919f 34#include "libavutil/opt.h"
dbbec0c2 35#include "internal.h"
11d6f38c 36#include "aac_ac3_parser.h"
9fc1ab72 37#include "ac3_parser.h"
58ce349f 38#include "ac3dec.h"
227322b8 39#include "ac3dec_data.h"
a45fbda9 40#include "kbdwin.h"
98a27a8a 41
7417120b
JR
42/**
43 * table for ungrouping 3 values in 7 bits.
44 * used for exponents and bap=2 mantissas
45 */
46static uint8_t ungroup_3_in_7_bits_tab[128][3];
967d397a 47
5aefe3eb 48/** tables for ungrouping mantissas */
a4de6dd2
JR
49static int b1_mantissas[32][3];
50static int b2_mantissas[128][3];
51static int b3_mantissas[8];
52static int b4_mantissas[128][2];
53static int b5_mantissas[16];
967d397a 54
5aefe3eb
JR
55/**
56 * Quantization table: levels for symmetric. bits for asymmetric.
57 * reference: Table 7.18 Mapping of bap to Quantizer
58 */
e2270b4e 59static const uint8_t quantization_tab[16] = {
5aefe3eb
JR
60 0, 3, 5, 7, 11, 15,
61 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
62};
967d397a 63
3357ff33 64/** dynamic range table. converts codes to scale factors. */
e2270b4e 65static float dynamic_range_tab[256];
3357ff33 66
5066f515 67/** Adjustments in dB gain */
caf0fbc8
JR
68static const float gain_levels[9] = {
69 LEVEL_PLUS_3DB,
70 LEVEL_PLUS_1POINT5DB,
3bbb0bf8 71 LEVEL_ONE,
caf0fbc8 72 LEVEL_MINUS_1POINT5DB,
3bbb0bf8
JR
73 LEVEL_MINUS_3DB,
74 LEVEL_MINUS_4POINT5DB,
75 LEVEL_MINUS_6DB,
caf0fbc8 76 LEVEL_ZERO,
3bbb0bf8
JR
77 LEVEL_MINUS_9DB
78};
967d397a 79
3bbb0bf8 80/**
3bbb0bf8
JR
81 * Table for default stereo downmixing coefficients
82 * reference: Section 7.8.2 Downmixing Into Two Channels
83 */
84static const uint8_t ac3_default_coeffs[8][5][2] = {
caf0fbc8
JR
85 { { 2, 7 }, { 7, 2 }, },
86 { { 4, 4 }, },
87 { { 2, 7 }, { 7, 2 }, },
88 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
89 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
90 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
91 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
92 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
3bbb0bf8 93};
967d397a 94
2fbbd087 95/**
5066f515
JR
96 * Symmetrical Dequantization
97 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
98 * Tables 7.19 to 7.23
99 */
a4de6dd2 100static inline int
5aefe3eb 101symmetric_dequant(int code, int levels)
98a27a8a 102{
a4de6dd2 103 return ((code - (levels >> 1)) << 24) / levels;
98a27a8a
JR
104}
105
c7cfc48f
JR
106/*
107 * Initialize tables at runtime.
108 */
98a6fff9 109static av_cold void ac3_tables_init(void)
00585845 110{
4415076f 111 int i;
98a27a8a 112
7417120b
JR
113 /* generate table for ungrouping 3 values in 7 bits
114 reference: Section 7.1.3 Exponent Decoding */
541d083a 115 for (i = 0; i < 128; i++) {
7417120b
JR
116 ungroup_3_in_7_bits_tab[i][0] = i / 25;
117 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
118 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
119 }
120
5aefe3eb
JR
121 /* generate grouped mantissa tables
122 reference: Section 7.3.5 Ungrouping of Mantissas */
541d083a 123 for (i = 0; i < 32; i++) {
5aefe3eb 124 /* bap=1 mantissas */
602116df
JR
125 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
126 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
127 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
5aefe3eb 128 }
541d083a 129 for (i = 0; i < 128; i++) {
5aefe3eb 130 /* bap=2 mantissas */
7417120b
JR
131 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
132 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
133 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
5aefe3eb
JR
134
135 /* bap=4 mantissas */
136 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
137 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
138 }
139 /* generate ungrouped mantissa tables
140 reference: Tables 7.21 and 7.23 */
541d083a 141 for (i = 0; i < 7; i++) {
5aefe3eb
JR
142 /* bap=3 mantissas */
143 b3_mantissas[i] = symmetric_dequant(i, 7);
144 }
541d083a 145 for (i = 0; i < 15; i++) {
5aefe3eb
JR
146 /* bap=5 mantissas */
147 b5_mantissas[i] = symmetric_dequant(i, 15);
148 }
c7cfc48f 149
3357ff33
JR
150 /* generate dynamic range table
151 reference: Section 7.7.1 Dynamic Range Control */
541d083a 152 for (i = 0; i < 256; i++) {
3357ff33 153 int v = (i >> 5) - ((i >> 7) << 3) - 5;
e2270b4e 154 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
3357ff33 155 }
00585845
JR
156}
157
5066f515
JR
158/**
159 * AVCodec initialization
160 */
98a6fff9 161static av_cold int ac3_decode_init(AVCodecContext *avctx)
1b293437 162{
d802d7ca 163 AC3DecodeContext *s = avctx->priv_data;
30b39164
MR
164 int i;
165
d802d7ca 166 s->avctx = avctx;
1b293437 167
4c57cde9 168 ff_ac3_common_init();
98a27a8a 169 ac3_tables_init();
7d485f16
SS
170 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
171 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
3ed546fe 172 ff_kbd_window_init(s->window, 5.0, 256);
9cf0841e 173 ff_dsputil_init(&s->dsp, avctx);
e034cc6c 174 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
6d9f52b2 175 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
c73d99e6 176 ff_fmt_convert_init(&s->fmt_conv, avctx);
ec0350c9 177 av_lfg_init(&s->dith_state, 0);
2aa2c5c4 178
b8f3ab8e 179 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
4e092320 180
95283c17 181 /* allow downmixing to stereo or mono */
b5328546
TW
182#if FF_API_REQUEST_CHANNELS
183FF_DISABLE_DEPRECATION_WARNINGS
184 if (avctx->request_channels == 1)
185 avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
186 else if (avctx->request_channels == 2)
187 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
188FF_ENABLE_DEPRECATION_WARNINGS
189#endif
190 if (avctx->channels > 1 &&
191 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
192 avctx->channels = 1;
193 else if (avctx->channels > 2 &&
194 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
195 avctx->channels = 2;
38dae9c3 196 s->downmixed = 1;
95283c17 197
30b39164 198 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
30b39164
MR
199 s->xcfptr[i] = s->transform_coeffs[i];
200 s->dlyptr[i] = s->delay[i];
201 }
202
1b293437 203 return 0;
2aa2c5c4
JR
204}
205
9fc1ab72 206/**
5066f515 207 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
c7cfc48f 208 * GetBitContext within AC3DecodeContext must point to
14b70628 209 * the start of the synchronized AC-3 bitstream.
c7cfc48f 210 */
d802d7ca 211static int ac3_parse_header(AC3DecodeContext *s)
2aa2c5c4 212{
4397d95c
JR
213 GetBitContext *gbc = &s->gbc;
214 int i;
215
216 /* read the rest of the bsi. read twice for dual mono mode. */
3dc99a18 217 i = !s->channel_mode;
4397d95c
JR
218 do {
219 skip_bits(gbc, 5); // skip dialog normalization
220 if (get_bits1(gbc))
221 skip_bits(gbc, 8); //skip compression
222 if (get_bits1(gbc))
223 skip_bits(gbc, 8); //skip language code
224 if (get_bits1(gbc))
225 skip_bits(gbc, 7); //skip audio production information
226 } while (i--);
227
228 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
229
230 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
231 TODO: read & use the xbsi1 downmix levels */
232 if (get_bits1(gbc))
233 skip_bits(gbc, 14); //skip timecode1 / xbsi1
234 if (get_bits1(gbc))
235 skip_bits(gbc, 14); //skip timecode2 / xbsi2
236
237 /* skip additional bitstream info */
238 if (get_bits1(gbc)) {
239 i = get_bits(gbc, 6);
240 do {
241 skip_bits(gbc, 8);
541d083a 242 } while (i--);
4397d95c
JR
243 }
244
245 return 0;
246}
247
248/**
14b70628 249 * Common function to parse AC-3 or E-AC-3 frame header
4397d95c
JR
250 */
251static int parse_frame_header(AC3DecodeContext *s)
252{
9fc1ab72 253 AC3HeaderInfo hdr;
4397d95c 254 int err;
9fc1ab72 255
6f89efea 256 err = avpriv_ac3_parse_header(&s->gbc, &hdr);
541d083a 257 if (err)
9fc1ab72
JR
258 return err;
259
260 /* get decoding parameters from header info */
d802d7ca 261 s->bit_alloc_params.sr_code = hdr.sr_code;
be187388 262 s->bitstream_mode = hdr.bitstream_mode;
d802d7ca 263 s->channel_mode = hdr.channel_mode;
1b70d88b 264 s->lfe_on = hdr.lfe_on;
d802d7ca 265 s->bit_alloc_params.sr_shift = hdr.sr_shift;
866181e5 266 s->sample_rate = hdr.sample_rate;
d802d7ca
JR
267 s->bit_rate = hdr.bit_rate;
268 s->channels = hdr.channels;
269 s->fbw_channels = s->channels - s->lfe_on;
270 s->lfe_ch = s->fbw_channels + 1;
271 s->frame_size = hdr.frame_size;
55736cfb
BW
272 s->center_mix_level = hdr.center_mix_level;
273 s->surround_mix_level = hdr.surround_mix_level;
6730e9f3 274 s->num_blocks = hdr.num_blocks;
be5f17b9 275 s->frame_type = hdr.frame_type;
3596aa6f 276 s->substreamid = hdr.substreamid;
7bfd22f2 277
541d083a
CB
278 if (s->lfe_on) {
279 s->start_freq[s->lfe_ch] = 0;
280 s->end_freq[s->lfe_ch] = 7;
6e74513a
JR
281 s->num_exp_groups[s->lfe_ch] = 2;
282 s->channel_in_cpl[s->lfe_ch] = 0;
283 }
284
bf09b550
JR
285 if (hdr.bitstream_id <= 10) {
286 s->eac3 = 0;
287 s->snr_offset_strategy = 2;
288 s->block_switch_syntax = 1;
289 s->dither_flag_syntax = 1;
290 s->bit_allocation_syntax = 1;
291 s->fast_gain_syntax = 0;
292 s->first_cpl_leak = 0;
293 s->dba_syntax = 1;
294 s->skip_syntax = 1;
295 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
ab2a942a 296 return ac3_parse_header(s);
d1515324 297 } else if (CONFIG_EAC3_DECODER) {
1f6a594d
JR
298 s->eac3 = 1;
299 return ff_eac3_parse_header(s);
d1515324
DB
300 } else {
301 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
b1f9cdc3 302 return AVERROR(ENOSYS);
bf09b550 303 }
f0b3a7ba
JR
304}
305
306/**
307 * Set stereo downmixing coefficients based on frame header info.
308 * reference: Section 7.8.2 Downmixing Into Two Channels
309 */
310static void set_downmix_coeffs(AC3DecodeContext *s)
311{
312 int i;
e6d9fa66
MN
313 float cmix = gain_levels[s-> center_mix_level];
314 float smix = gain_levels[s->surround_mix_level];
557ac0c4 315 float norm0, norm1;
f0b3a7ba 316
541d083a 317 for (i = 0; i < s->fbw_channels; i++) {
d802d7ca
JR
318 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
319 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
3bbb0bf8 320 }
541d083a 321 if (s->channel_mode > 1 && s->channel_mode & 1) {
f0b3a7ba 322 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
3bbb0bf8 323 }
541d083a 324 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
d802d7ca 325 int nf = s->channel_mode - 2;
f0b3a7ba 326 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
3bbb0bf8 327 }
541d083a 328 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
d802d7ca 329 int nf = s->channel_mode - 4;
f0b3a7ba 330 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
3bbb0bf8 331 }
9d10e6e6 332
557ac0c4
LM
333 /* renormalize */
334 norm0 = norm1 = 0.0;
541d083a 335 for (i = 0; i < s->fbw_channels; i++) {
557ac0c4
LM
336 norm0 += s->downmix_coeffs[i][0];
337 norm1 += s->downmix_coeffs[i][1];
338 }
339 norm0 = 1.0f / norm0;
340 norm1 = 1.0f / norm1;
541d083a 341 for (i = 0; i < s->fbw_channels; i++) {
557ac0c4
LM
342 s->downmix_coeffs[i][0] *= norm0;
343 s->downmix_coeffs[i][1] *= norm1;
344 }
345
541d083a
CB
346 if (s->output_mode == AC3_CHMODE_MONO) {
347 for (i = 0; i < s->fbw_channels; i++)
348 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
349 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
9d10e6e6 350 }
2aa2c5c4
JR
351}
352
3bb004fc 353/**
5066f515
JR
354 * Decode the grouped exponents according to exponent strategy.
355 * reference: Section 7.1.3 Exponent Decoding
2aa2c5c4 356 */
ce7d842f 357static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
80670324 358 uint8_t absexp, int8_t *dexps)
2aa2c5c4 359{
e2270b4e 360 int i, j, grp, group_size;
4415076f
JR
361 int dexp[256];
362 int expacc, prevexp;
363
364 /* unpack groups */
e2270b4e 365 group_size = exp_strategy + (exp_strategy == EXP_D45);
541d083a 366 for (grp = 0, i = 0; grp < ngrps; grp++) {
23c8cb89 367 expacc = get_bits(gbc, 7);
7417120b
JR
368 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
369 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
370 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
4415076f 371 }
2aa2c5c4 372
4415076f
JR
373 /* convert to absolute exps and expand groups */
374 prevexp = absexp;
541d083a 375 for (i = 0, j = 0; i < ngrps * 3; i++) {
ce7d842f 376 prevexp += dexp[i] - 2;
2ceccf04 377 if (prevexp > 24U)
ce7d842f 378 return -1;
96f229d6 379 switch (group_size) {
541d083a
CB
380 case 4: dexps[j++] = prevexp;
381 dexps[j++] = prevexp;
382 case 2: dexps[j++] = prevexp;
383 case 1: dexps[j++] = prevexp;
1b293437 384 }
2aa2c5c4 385 }
ce7d842f 386 return 0;
2aa2c5c4
JR
387}
388
d7dc7ad0 389/**
5066f515 390 * Generate transform coefficients for each coupled channel in the coupling
d7dc7ad0
JR
391 * range using the coupling coefficients and coupling coordinates.
392 * reference: Section 7.4.3 Coupling Coordinate Format
393 */
5e3e4075 394static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
d7dc7ad0 395{
3b6c5ad2 396 int bin, band, ch;
02587373
JR
397
398 bin = s->start_freq[CPL_CH];
399 for (band = 0; band < s->num_cpl_bands; band++) {
8b11b44e 400 int band_start = bin;
3b6c5ad2 401 int band_end = bin + s->cpl_band_sizes[band];
8b11b44e
JR
402 for (ch = 1; ch <= s->fbw_channels; ch++) {
403 if (s->channel_in_cpl[ch]) {
1460c790 404 int cpl_coord = s->cpl_coords[ch][band] << 5;
8b11b44e 405 for (bin = band_start; bin < band_end; bin++) {
541d083a
CB
406 s->fixed_coeffs[ch][bin] =
407 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
8b11b44e
JR
408 }
409 if (ch == 2 && s->phase_flags[band]) {
410 for (bin = band_start; bin < band_end; bin++)
411 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
d7dc7ad0 412 }
b972c06a 413 }
60313902 414 }
8b11b44e 415 bin = band_end;
d7dc7ad0
JR
416 }
417}
418
5066f515
JR
419/**
420 * Grouped mantissas for 3-level 5-level and 11-level quantization
421 */
422typedef struct {
d869a460
JGG
423 int b1_mant[2];
424 int b2_mant[2];
425 int b4_mant;
426 int b1;
427 int b2;
428 int b4;
486637af
JR
429} mant_groups;
430
5066f515 431/**
e522bd49 432 * Decode the transform coefficients for a particular channel
5066f515
JR
433 * reference: Section 7.3 Quantization and Decoding of Mantissas
434 */
e43b29ab 435static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
1b293437 436{
d869a460 437 int start_freq = s->start_freq[ch_index];
541d083a
CB
438 int end_freq = s->end_freq[ch_index];
439 uint8_t *baps = s->bap[ch_index];
440 int8_t *exps = s->dexps[ch_index];
b6293e27 441 int32_t *coeffs = s->fixed_coeffs[ch_index];
541d083a 442 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
d802d7ca 443 GetBitContext *gbc = &s->gbc;
d869a460 444 int freq;
2fbbd087 445
541d083a 446 for (freq = start_freq; freq < end_freq; freq++) {
d869a460
JGG
447 int bap = baps[freq];
448 int mantissa;
541d083a
CB
449 switch (bap) {
450 case 0:
04ea5491 451 /* random noise with approximate range of -0.707 to 0.707 */
541d083a 452 if (dither)
04ea5491 453 mantissa = (av_lfg_get(&s->dith_state) / 362) - 5932275;
541d083a
CB
454 else
455 mantissa = 0;
456 break;
457 case 1:
458 if (m->b1) {
459 m->b1--;
460 mantissa = m->b1_mant[m->b1];
461 } else {
462 int bits = get_bits(gbc, 5);
463 mantissa = b1_mantissas[bits][0];
464 m->b1_mant[1] = b1_mantissas[bits][1];
465 m->b1_mant[0] = b1_mantissas[bits][2];
466 m->b1 = 2;
467 }
468 break;
469 case 2:
470 if (m->b2) {
471 m->b2--;
472 mantissa = m->b2_mant[m->b2];
473 } else {
474 int bits = get_bits(gbc, 7);
475 mantissa = b2_mantissas[bits][0];
476 m->b2_mant[1] = b2_mantissas[bits][1];
477 m->b2_mant[0] = b2_mantissas[bits][2];
478 m->b2 = 2;
479 }
480 break;
481 case 3:
482 mantissa = b3_mantissas[get_bits(gbc, 3)];
483 break;
484 case 4:
485 if (m->b4) {
486 m->b4 = 0;
487 mantissa = m->b4_mant;
488 } else {
489 int bits = get_bits(gbc, 7);
490 mantissa = b4_mantissas[bits][0];
491 m->b4_mant = b4_mantissas[bits][1];
492 m->b4 = 1;
493 }
494 break;
495 case 5:
496 mantissa = b5_mantissas[get_bits(gbc, 4)];
497 break;
498 default: /* 6 to 15 */
499 /* Shift mantissa and sign-extend it. */
500 mantissa = get_sbits(gbc, quantization_tab[bap]);
501 mantissa <<= 24 - quantization_tab[bap];
502 break;
1b293437 503 }
d869a460 504 coeffs[freq] = mantissa >> exps[freq];
1b293437 505 }
1b293437
JR
506}
507
60f07fad 508/**
25dcd182
JR
509 * Remove random dithering from coupling range coefficients with zero-bit
510 * mantissas for coupled channels which do not use dithering.
60f07fad
JR
511 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
512 */
d802d7ca 513static void remove_dithering(AC3DecodeContext *s) {
60f07fad 514 int ch, i;
60f07fad 515
541d083a
CB
516 for (ch = 1; ch <= s->fbw_channels; ch++) {
517 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
518 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
519 if (!s->bap[CPL_CH][i])
25dcd182 520 s->fixed_coeffs[ch][i] = 0;
60f07fad
JR
521 }
522 }
523 }
524}
525
6a68105e 526static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
541d083a 527 mant_groups *m)
bf09b550
JR
528{
529 if (!s->channel_uses_aht[ch]) {
6a68105e 530 ac3_decode_transform_coeffs_ch(s, ch, m);
bf09b550
JR
531 } else {
532 /* if AHT is used, mantissas for all blocks are encoded in the first
533 block of the frame. */
534 int bin;
d1515324 535 if (!blk && CONFIG_EAC3_DECODER)
6a68105e 536 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
bf09b550 537 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
ae04de31 538 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
bf09b550
JR
539 }
540 }
541}
bf09b550 542
5066f515 543/**
164e169f 544 * Decode the transform coefficients.
c7cfc48f 545 */
e43b29ab 546static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
1b293437 547{
7b4076a7 548 int ch, end;
1b293437 549 int got_cplchan = 0;
486637af
JR
550 mant_groups m;
551
d869a460 552 m.b1 = m.b2 = m.b4 = 0;
1b293437 553
d802d7ca 554 for (ch = 1; ch <= s->channels; ch++) {
5066f515 555 /* transform coefficients for full-bandwidth channel */
e43b29ab 556 decode_transform_coeffs_ch(s, blk, ch, &m);
511cf612 557 /* transform coefficients for coupling channel come right after the
5066f515 558 coefficients for the first coupled channel*/
d802d7ca 559 if (s->channel_in_cpl[ch]) {
486637af 560 if (!got_cplchan) {
e43b29ab 561 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
5e3e4075 562 calc_transform_coeffs_cpl(s);
486637af
JR
563 got_cplchan = 1;
564 }
d802d7ca 565 end = s->end_freq[CPL_CH];
eaf84d97 566 } else {
d802d7ca 567 end = s->end_freq[ch];
eaf84d97 568 }
486637af 569 do
bd98e9e2 570 s->fixed_coeffs[ch][end] = 0;
541d083a 571 while (++end < 256);
486637af 572 }
1b293437 573
ea364c74 574 /* zero the dithered coefficients for appropriate channels */
86662b1c 575 remove_dithering(s);
2aa2c5c4
JR
576}
577
8b60bbbf 578/**
5066f515 579 * Stereo rematrixing.
8b60bbbf
JR
580 * reference: Section 7.5.4 Rematrixing : Decoding Technique
581 */
d802d7ca 582static void do_rematrixing(AC3DecodeContext *s)
1b293437 583{
8b60bbbf 584 int bnd, i;
2fbbd087
JR
585 int end, bndend;
586
d802d7ca 587 end = FFMIN(s->end_freq[1], s->end_freq[2]);
1b293437 588
541d083a
CB
589 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
590 if (s->rematrixing_flags[bnd]) {
591 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
592 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
2ed44396 593 int tmp0 = s->fixed_coeffs[1][i];
3fdccca0 594 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
2ed44396 595 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
8b60bbbf
JR
596 }
597 }
1b293437
JR
598 }
599}
2aa2c5c4 600
5066f515 601/**
5066f515
JR
602 * Inverse MDCT Transform.
603 * Convert frequency domain coefficients to time-domain audio samples.
604 * reference: Section 7.9.4 Transformation Equations
605 */
38dae9c3 606static inline void do_imdct(AC3DecodeContext *s, int channels)
486637af 607{
0de73a46 608 int ch;
7b4076a7 609
541d083a 610 for (ch = 1; ch <= channels; ch++) {
d802d7ca 611 if (s->block_switch[ch]) {
916d5d6c 612 int i;
541d083a
CB
613 float *x = s->tmp_output + 128;
614 for (i = 0; i < 128; i++)
615 x[i] = s->transform_coeffs[ch][2 * i];
26f548bb 616 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
e034cc6c
JR
617 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
618 s->tmp_output, s->window, 128);
541d083a
CB
619 for (i = 0; i < 128; i++)
620 x[i] = s->transform_coeffs[ch][2 * i + 1];
621 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
eaf84d97 622 } else {
26f548bb 623 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
e034cc6c
JR
624 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
625 s->tmp_output, s->window, 128);
541d083a 626 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
eaf84d97 627 }
486637af
JR
628 }
629}
630
3bbb0bf8 631/**
38dae9c3
JR
632 * Upmix delay samples from stereo to original channel layout.
633 */
634static void ac3_upmix_delay(AC3DecodeContext *s)
635{
e6300276 636 int channel_data_size = sizeof(s->delay[0]);
541d083a
CB
637 switch (s->channel_mode) {
638 case AC3_CHMODE_DUALMONO:
639 case AC3_CHMODE_STEREO:
640 /* upmix mono to stereo */
641 memcpy(s->delay[1], s->delay[0], channel_data_size);
642 break;
643 case AC3_CHMODE_2F2R:
644 memset(s->delay[3], 0, channel_data_size);
645 case AC3_CHMODE_2F1R:
646 memset(s->delay[2], 0, channel_data_size);
647 break;
648 case AC3_CHMODE_3F2R:
649 memset(s->delay[4], 0, channel_data_size);
650 case AC3_CHMODE_3F1R:
651 memset(s->delay[3], 0, channel_data_size);
652 case AC3_CHMODE_3F:
653 memcpy(s->delay[2], s->delay[1], channel_data_size);
654 memset(s->delay[1], 0, channel_data_size);
655 break;
38dae9c3
JR
656 }
657}
658
659/**
0c5d750d 660 * Decode band structure for coupling, spectral extension, or enhanced coupling.
eb98cdfa
JR
661 * The band structure defines how many subbands are in each band. For each
662 * subband in the range, 1 means it is combined with the previous band, and 0
663 * means that it starts a new band.
664 *
0c5d750d
JR
665 * @param[in] gbc bit reader context
666 * @param[in] blk block number
667 * @param[in] eac3 flag to indicate E-AC-3
668 * @param[in] ecpl flag to indicate enhanced coupling
669 * @param[in] start_subband subband number for start of range
670 * @param[in] end_subband subband number for end of range
671 * @param[in] default_band_struct default band structure table
0c5d750d
JR
672 * @param[out] num_bands number of bands (optionally NULL)
673 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
674 */
675static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
676 int ecpl, int start_subband, int end_subband,
677 const uint8_t *default_band_struct,
c36ea060 678 int *num_bands, uint8_t *band_sizes)
0c5d750d 679{
f23dc1e1 680 int subbnd, bnd, n_subbands, n_bands=0;
75b53b21 681 uint8_t bnd_sz[22];
3f937168
JR
682 uint8_t coded_band_struct[22];
683 const uint8_t *band_struct;
0c5d750d
JR
684
685 n_subbands = end_subband - start_subband;
686
687 /* decode band structure from bitstream or use default */
688 if (!eac3 || get_bits1(gbc)) {
689 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
3f937168 690 coded_band_struct[subbnd] = get_bits1(gbc);
0c5d750d 691 }
3f937168 692 band_struct = coded_band_struct;
0c5d750d 693 } else if (!blk) {
3f937168
JR
694 band_struct = &default_band_struct[start_subband+1];
695 } else {
696 /* no change in band structure */
697 return;
0c5d750d 698 }
0c5d750d
JR
699
700 /* calculate number of bands and band sizes based on band structure.
701 note that the first 4 subbands in enhanced coupling span only 6 bins
702 instead of 12. */
703 if (num_bands || band_sizes ) {
e202cc25 704 n_bands = n_subbands;
0c5d750d
JR
705 bnd_sz[0] = ecpl ? 6 : 12;
706 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
707 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
541d083a 708 if (band_struct[subbnd - 1]) {
0c5d750d
JR
709 n_bands--;
710 bnd_sz[bnd] += subbnd_size;
711 } else {
712 bnd_sz[++bnd] = subbnd_size;
713 }
714 }
715 }
716
717 /* set optional output params */
0c5d750d
JR
718 if (num_bands)
719 *num_bands = n_bands;
720 if (band_sizes)
75b53b21 721 memcpy(band_sizes, bnd_sz, n_bands);
0c5d750d
JR
722}
723
724/**
022845ed 725 * Decode a single audio block from the AC-3 bitstream.
c7cfc48f 726 */
022845ed 727static int decode_audio_block(AC3DecodeContext *s, int blk)
2aa2c5c4 728{
d802d7ca
JR
729 int fbw_channels = s->fbw_channels;
730 int channel_mode = s->channel_mode;
0bff58a5 731 int i, bnd, seg, ch;
38dae9c3
JR
732 int different_transforms;
733 int downmix_output;
54624396 734 int cpl_in_use;
d802d7ca 735 GetBitContext *gbc = &s->gbc;
a92be9b8 736 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
7b4076a7 737
5066f515 738 /* block switch flags */
38dae9c3 739 different_transforms = 0;
bf09b550 740 if (s->block_switch_syntax) {
ab2a942a
JR
741 for (ch = 1; ch <= fbw_channels; ch++) {
742 s->block_switch[ch] = get_bits1(gbc);
541d083a 743 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
ab2a942a
JR
744 different_transforms = 1;
745 }
bf09b550 746 }
98a27a8a 747
5066f515 748 /* dithering flags */
bf09b550 749 if (s->dither_flag_syntax) {
ab2a942a
JR
750 for (ch = 1; ch <= fbw_channels; ch++) {
751 s->dither_flag[ch] = get_bits1(gbc);
ab2a942a 752 }
bf09b550 753 }
98a27a8a 754
77416325 755 /* dynamic range */
3dc99a18 756 i = !s->channel_mode;
77416325 757 do {
541d083a 758 if (get_bits1(gbc)) {
c9ca220e
JS
759 s->dynamic_range[i] = powf(dynamic_range_tab[get_bits(gbc, 8)],
760 s->drc_scale);
541d083a 761 } else if (blk == 0) {
d802d7ca 762 s->dynamic_range[i] = 1.0f;
9fc1ab72 763 }
541d083a 764 } while (i--);
98a27a8a 765
6fafb020
JR
766 /* spectral extension strategy */
767 if (s->eac3 && (!blk || get_bits1(gbc))) {
ca6e7708
CEH
768 s->spx_in_use = get_bits1(gbc);
769 if (s->spx_in_use) {
770 int dst_start_freq, dst_end_freq, src_start_freq,
771 start_subband, end_subband;
772
773 /* determine which channels use spx */
774 if (s->channel_mode == AC3_CHMODE_MONO) {
775 s->channel_uses_spx[1] = 1;
776 } else {
777 for (ch = 1; ch <= fbw_channels; ch++)
778 s->channel_uses_spx[ch] = get_bits1(gbc);
779 }
780
781 /* get the frequency bins of the spx copy region and the spx start
782 and end subbands */
783 dst_start_freq = get_bits(gbc, 2);
784 start_subband = get_bits(gbc, 3) + 2;
785 if (start_subband > 7)
786 start_subband += start_subband - 7;
787 end_subband = get_bits(gbc, 3) + 5;
788 if (end_subband > 7)
789 end_subband += end_subband - 7;
790 dst_start_freq = dst_start_freq * 12 + 25;
791 src_start_freq = start_subband * 12 + 25;
792 dst_end_freq = end_subband * 12 + 25;
793
794 /* check validity of spx ranges */
795 if (start_subband >= end_subband) {
796 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
797 "range (%d >= %d)\n", start_subband, end_subband);
b1f9cdc3 798 return AVERROR_INVALIDDATA;
ca6e7708
CEH
799 }
800 if (dst_start_freq >= src_start_freq) {
801 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
802 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
b1f9cdc3 803 return AVERROR_INVALIDDATA;
ca6e7708
CEH
804 }
805
806 s->spx_dst_start_freq = dst_start_freq;
807 s->spx_src_start_freq = src_start_freq;
808 s->spx_dst_end_freq = dst_end_freq;
809
810 decode_band_structure(gbc, blk, s->eac3, 0,
811 start_subband, end_subband,
812 ff_eac3_default_spx_band_struct,
813 &s->num_spx_bands,
814 s->spx_band_sizes);
815 } else {
816 for (ch = 1; ch <= fbw_channels; ch++) {
817 s->channel_uses_spx[ch] = 0;
818 s->first_spx_coords[ch] = 1;
819 }
6fafb020 820 }
6fafb020
JR
821 }
822
ca6e7708
CEH
823 /* spectral extension coordinates */
824 if (s->spx_in_use) {
825 for (ch = 1; ch <= fbw_channels; ch++) {
826 if (s->channel_uses_spx[ch]) {
827 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
828 float spx_blend;
829 int bin, master_spx_coord;
830
831 s->first_spx_coords[ch] = 0;
832 spx_blend = get_bits(gbc, 5) * (1.0f/32);
833 master_spx_coord = get_bits(gbc, 2) * 3;
834
835 bin = s->spx_src_start_freq;
836 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
837 int bandsize;
838 int spx_coord_exp, spx_coord_mant;
839 float nratio, sblend, nblend, spx_coord;
840
841 /* calculate blending factors */
842 bandsize = s->spx_band_sizes[bnd];
843 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
844 nratio = av_clipf(nratio, 0.0f, 1.0f);
541d083a
CB
845 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
846 // to give unity variance
ca6e7708
CEH
847 sblend = sqrtf(1.0f - nratio);
848 bin += bandsize;
849
850 /* decode spx coordinates */
851 spx_coord_exp = get_bits(gbc, 4);
852 spx_coord_mant = get_bits(gbc, 2);
853 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
854 else spx_coord_mant += 4;
855 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
541d083a 856 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
ca6e7708
CEH
857
858 /* multiply noise and signal blending factors by spx coordinate */
859 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
860 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
861 }
862 }
863 } else {
864 s->first_spx_coords[ch] = 1;
865 }
866 }
867 }
6fafb020 868
5066f515 869 /* coupling strategy */
225c3042 870 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
7b4076a7 871 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
6fafb020 872 if (!s->eac3)
0569993e 873 s->cpl_in_use[blk] = get_bits1(gbc);
4760aec6 874 if (s->cpl_in_use[blk]) {
5066f515 875 /* coupling in use */
24834c19 876 int cpl_start_subband, cpl_end_subband;
b6acc57f 877
3af91313
JR
878 if (channel_mode < AC3_CHMODE_STEREO) {
879 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
b1f9cdc3 880 return AVERROR_INVALIDDATA;
3af91313
JR
881 }
882
6fafb020
JR
883 /* check for enhanced coupling */
884 if (s->eac3 && get_bits1(gbc)) {
885 /* TODO: parse enhanced coupling strategy info */
12e25ed2 886 avpriv_request_sample(s->avctx, "Enhanced coupling");
717addec 887 return AVERROR_PATCHWELCOME;
6fafb020
JR
888 }
889
5066f515 890 /* determine which channels are coupled */
6fafb020
JR
891 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
892 s->channel_in_cpl[1] = 1;
893 s->channel_in_cpl[2] = 1;
894 } else {
0569993e
JR
895 for (ch = 1; ch <= fbw_channels; ch++)
896 s->channel_in_cpl[ch] = get_bits1(gbc);
6fafb020 897 }
98a27a8a 898
5066f515 899 /* phase flags in use */
e59cc205 900 if (channel_mode == AC3_CHMODE_STEREO)
d802d7ca 901 s->phase_flags_in_use = get_bits1(gbc);
98a27a8a 902
6fafb020 903 /* coupling frequency range */
24834c19 904 cpl_start_subband = get_bits(gbc, 4);
ca6e7708
CEH
905 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
906 get_bits(gbc, 4) + 3;
1ac7d1ac
JR
907 if (cpl_start_subband >= cpl_end_subband) {
908 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
6ee6d068 909 cpl_start_subband, cpl_end_subband);
b1f9cdc3 910 return AVERROR_INVALIDDATA;
98a27a8a 911 }
24834c19 912 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
6ee6d068 913 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
6fafb020 914
778bc09b
JR
915 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
916 cpl_end_subband,
917 ff_eac3_default_cpl_band_struct,
c36ea060 918 &s->num_cpl_bands, s->cpl_band_sizes);
878c40a1 919 } else {
5066f515 920 /* coupling not in use */
6fafb020 921 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 922 s->channel_in_cpl[ch] = 0;
6fafb020
JR
923 s->first_cpl_coords[ch] = 1;
924 }
63d72fb1 925 s->first_cpl_leak = s->eac3;
6fafb020 926 s->phase_flags_in_use = 0;
1b293437 927 }
6fafb020 928 } else if (!s->eac3) {
541d083a
CB
929 if (!blk) {
930 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
931 "be present in block 0\n");
b1f9cdc3 932 return AVERROR_INVALIDDATA;
0569993e
JR
933 } else {
934 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
935 }
6fafb020 936 }
4760aec6 937 cpl_in_use = s->cpl_in_use[blk];
98a27a8a 938
5066f515 939 /* coupling coordinates */
54624396 940 if (cpl_in_use) {
e2270b4e 941 int cpl_coords_exist = 0;
98a27a8a 942
e2270b4e 943 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 944 if (s->channel_in_cpl[ch]) {
225c3042 945 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
e2270b4e 946 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
225c3042 947 s->first_cpl_coords[ch] = 0;
e2270b4e 948 cpl_coords_exist = 1;
23c8cb89 949 master_cpl_coord = 3 * get_bits(gbc, 2);
d802d7ca 950 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
23c8cb89
JR
951 cpl_coord_exp = get_bits(gbc, 4);
952 cpl_coord_mant = get_bits(gbc, 4);
e2270b4e 953 if (cpl_coord_exp == 15)
a4de6dd2 954 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
486637af 955 else
a4de6dd2
JR
956 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
957 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
486637af 958 }
82a591d8 959 } else if (!blk) {
541d083a
CB
960 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
961 "be present in block 0\n");
b1f9cdc3 962 return AVERROR_INVALIDDATA;
486637af 963 }
225c3042
JR
964 } else {
965 /* channel not in coupling */
966 s->first_cpl_coords[ch] = 1;
eaf84d97
JR
967 }
968 }
5066f515 969 /* phase flags */
b02fbf75 970 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
d802d7ca 971 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
b02fbf75 972 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
eaf84d97
JR
973 }
974 }
2aa2c5c4 975 }
98a27a8a 976
5066f515 977 /* stereo rematrixing strategy and band structure */
e59cc205 978 if (channel_mode == AC3_CHMODE_STEREO) {
6fafb020 979 if ((s->eac3 && !blk) || get_bits1(gbc)) {
d802d7ca 980 s->num_rematrixing_bands = 4;
ca6e7708 981 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
e202cc25 982 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
ca6e7708
CEH
983 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
984 s->num_rematrixing_bands--;
985 }
541d083a 986 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
d802d7ca 987 s->rematrixing_flags[bnd] = get_bits1(gbc);
82a591d8 988 } else if (!blk) {
541d083a
CB
989 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
990 "new rematrixing strategy not present in block 0\n");
535497f1 991 s->num_rematrixing_bands = 0;
1b293437 992 }
98a27a8a
JR
993 }
994
5066f515 995 /* exponent strategies for each channel */
54624396 996 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
6b4bfed9 997 if (!s->eac3)
aec0407f 998 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
541d083a 999 if (s->exp_strategy[blk][ch] != EXP_REUSE)
7b4076a7
JR
1000 bit_alloc_stages[ch] = 3;
1001 }
1002
5066f515 1003 /* channel bandwidth */
e2270b4e 1004 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 1005 s->start_freq[ch] = 0;
da04be10 1006 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
b85a15fe 1007 int group_size;
d802d7ca
JR
1008 int prev = s->end_freq[ch];
1009 if (s->channel_in_cpl[ch])
1010 s->end_freq[ch] = s->start_freq[CPL_CH];
ca6e7708
CEH
1011 else if (s->channel_uses_spx[ch])
1012 s->end_freq[ch] = s->spx_src_start_freq;
00585845 1013 else {
23c8cb89 1014 int bandwidth_code = get_bits(gbc, 6);
e2270b4e 1015 if (bandwidth_code > 60) {
6c6f9272 1016 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
b1f9cdc3 1017 return AVERROR_INVALIDDATA;
00585845 1018 }
d802d7ca 1019 s->end_freq[ch] = bandwidth_code * 3 + 73;
1b293437 1020 }
da04be10 1021 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
541d083a
CB
1022 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1023 if (blk > 0 && s->end_freq[ch] != prev)
7b4076a7 1024 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00585845 1025 }
eaf84d97 1026 }
da04be10 1027 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
b85a15fe 1028 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
da04be10 1029 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
b85a15fe 1030 }
7b4076a7 1031
5066f515 1032 /* decode exponents for each channel */
54624396 1033 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
da04be10 1034 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
d802d7ca 1035 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
ce7d842f 1036 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1cdd567f
JR
1037 s->num_exp_groups[ch], s->dexps[ch][0],
1038 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
ce7d842f 1039 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
b1f9cdc3 1040 return AVERROR_INVALIDDATA;
ce7d842f 1041 }
541d083a 1042 if (ch != CPL_CH && ch != s->lfe_ch)
23c8cb89 1043 skip_bits(gbc, 2); /* skip gainrng */
1b293437 1044 }
eaf84d97 1045 }
98a27a8a 1046
5066f515 1047 /* bit allocation information */
bf09b550 1048 if (s->bit_allocation_syntax) {
ab2a942a
JR
1049 if (get_bits1(gbc)) {
1050 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1051 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1052 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1053 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
e202cc25 1054 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
541d083a 1055 for (ch = !cpl_in_use; ch <= s->channels; ch++)
ab2a942a
JR
1056 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1057 } else if (!blk) {
541d083a
CB
1058 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1059 "be present in block 0\n");
b1f9cdc3 1060 return AVERROR_INVALIDDATA;
ab2a942a 1061 }
bf09b550 1062 }
98a27a8a 1063
5066f515 1064 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
541d083a
CB
1065 if (!s->eac3 || !blk) {
1066 if (s->snr_offset_strategy && get_bits1(gbc)) {
f2e4eb62
JR
1067 int snr = 0;
1068 int csnr;
1069 csnr = (get_bits(gbc, 6) - 15) << 4;
1070 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1071 /* snr offset */
1072 if (ch == i || s->snr_offset_strategy == 2)
1073 snr = (csnr + get_bits(gbc, 4)) << 2;
1074 /* run at least last bit allocation stage if snr offset changes */
541d083a 1075 if (blk && s->snr_offset[ch] != snr) {
f2e4eb62
JR
1076 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1077 }
1078 s->snr_offset[ch] = snr;
8dfc56ec
JR
1079
1080 /* fast gain (normal AC-3 only) */
1081 if (!s->eac3) {
1082 int prev = s->fast_gain[ch];
f2e4eb62 1083 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
8dfc56ec 1084 /* run last 2 bit allocation stages if fast gain changes */
541d083a 1085 if (blk && prev != s->fast_gain[ch])
8dfc56ec 1086 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
8dfc56ec 1087 }
f2e4eb62 1088 }
8dfc56ec 1089 } else if (!s->eac3 && !blk) {
f2e4eb62 1090 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
b1f9cdc3 1091 return AVERROR_INVALIDDATA;
8dfc56ec 1092 }
1b293437 1093 }
98a27a8a 1094
6fafb020
JR
1095 /* fast gain (E-AC-3 only) */
1096 if (s->fast_gain_syntax && get_bits1(gbc)) {
1097 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1098 int prev = s->fast_gain[ch];
1099 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1100 /* run last 2 bit allocation stages if fast gain changes */
541d083a 1101 if (blk && prev != s->fast_gain[ch])
6fafb020
JR
1102 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1103 }
1104 } else if (s->eac3 && !blk) {
1105 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1106 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1107 }
1108
1109 /* E-AC-3 to AC-3 converter SNR offset */
1110 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1111 skip_bits(gbc, 10); // skip converter snr offset
1112 }
1113
5066f515 1114 /* coupling leak information */
54624396 1115 if (cpl_in_use) {
8dfc56ec
JR
1116 if (s->first_cpl_leak || get_bits1(gbc)) {
1117 int fl = get_bits(gbc, 3);
1118 int sl = get_bits(gbc, 3);
1119 /* run last 2 bit allocation stages for coupling channel if
1120 coupling leak changes */
541d083a
CB
1121 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1122 sl != s->bit_alloc_params.cpl_slow_leak)) {
f2e4eb62 1123 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
8dfc56ec
JR
1124 }
1125 s->bit_alloc_params.cpl_fast_leak = fl;
1126 s->bit_alloc_params.cpl_slow_leak = sl;
1127 } else if (!s->eac3 && !blk) {
541d083a
CB
1128 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1129 "be present in block 0\n");
b1f9cdc3 1130 return AVERROR_INVALIDDATA;
93a2c8c1 1131 }
8dfc56ec 1132 s->first_cpl_leak = 0;
43ad93a4 1133 }
98a27a8a 1134
5066f515 1135 /* delta bit allocation information */
bf09b550 1136 if (s->dba_syntax && get_bits1(gbc)) {
5066f515 1137 /* delta bit allocation exists (strategy) */
54624396 1138 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca
JR
1139 s->dba_mode[ch] = get_bits(gbc, 2);
1140 if (s->dba_mode[ch] == DBA_RESERVED) {
1141 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
b1f9cdc3 1142 return AVERROR_INVALIDDATA;
1b293437 1143 }
7b4076a7 1144 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1145 }
5066f515 1146 /* channel delta offset, len and bit allocation */
54624396 1147 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
d802d7ca 1148 if (s->dba_mode[ch] == DBA_NEW) {
4c64c8e9
JR
1149 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1150 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
d802d7ca
JR
1151 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1152 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
541d083a 1153 s->dba_values[ch][seg] = get_bits(gbc, 3);
1b293437 1154 }
e25973a1
JR
1155 /* run last 2 bit allocation stages if new dba values */
1156 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1157 }
eaf84d97 1158 }
541d083a
CB
1159 } else if (blk == 0) {
1160 for (ch = 0; ch <= s->channels; ch++) {
d802d7ca 1161 s->dba_mode[ch] = DBA_NONE;
9fc1ab72 1162 }
1b293437 1163 }
00585845 1164
5066f515 1165 /* Bit allocation */
541d083a
CB
1166 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1167 if (bit_alloc_stages[ch] > 2) {
7b4076a7 1168 /* Exponent mapping into PSD and PSD integration */
d802d7ca
JR
1169 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1170 s->start_freq[ch], s->end_freq[ch],
1171 s->psd[ch], s->band_psd[ch]);
eaf84d97 1172 }
541d083a 1173 if (bit_alloc_stages[ch] > 1) {
7b4076a7
JR
1174 /* Compute excitation function, Compute masking curve, and
1175 Apply delta bit allocation */
72a6244b 1176 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
541d083a
CB
1177 s->start_freq[ch], s->end_freq[ch],
1178 s->fast_gain[ch], (ch == s->lfe_ch),
1179 s->dba_mode[ch], s->dba_nsegs[ch],
20e04726 1180 s->dba_offsets[ch], s->dba_lengths[ch],
541d083a 1181 s->dba_values[ch], s->mask[ch])) {
72a6244b 1182 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
b1f9cdc3 1183 return AVERROR_INVALIDDATA;
72a6244b 1184 }
eaf84d97 1185 }
541d083a 1186 if (bit_alloc_stages[ch] > 0) {
7b4076a7 1187 /* Compute bit allocation */
bf09b550
JR
1188 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1189 ff_eac3_hebap_tab : ff_ac3_bap_tab;
6d9f52b2 1190 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
d802d7ca
JR
1191 s->start_freq[ch], s->end_freq[ch],
1192 s->snr_offset[ch],
1193 s->bit_alloc_params.floor,
bf09b550 1194 bap_tab, s->bap[ch]);
eaf84d97 1195 }
2fbbd087 1196 }
98a27a8a 1197
5066f515 1198 /* unused dummy data */
bf09b550 1199 if (s->skip_syntax && get_bits1(gbc)) {
23c8cb89 1200 int skipl = get_bits(gbc, 9);
541d083a 1201 while (skipl--)
23c8cb89 1202 skip_bits(gbc, 8);
1b293437 1203 }
f5cefb21 1204
1b293437 1205 /* unpack the transform coefficients
5066f515 1206 this also uncouples channels if coupling is in use. */
e43b29ab 1207 decode_transform_coeffs(s, blk);
486637af 1208
bf09b550
JR
1209 /* TODO: generate enhanced coupling coordinates and uncouple */
1210
1b293437 1211 /* recover coefficients if rematrixing is in use */
541d083a 1212 if (s->channel_mode == AC3_CHMODE_STEREO)
d802d7ca 1213 do_rematrixing(s);
1b293437 1214
03726b70 1215 /* apply scaling to coefficients (headroom, dynrng) */
541d083a 1216 for (ch = 1; ch <= s->channels; ch++) {
b8f3ab8e 1217 float gain = 1.0 / 4194304.0f;
541d083a
CB
1218 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1219 gain *= s->dynamic_range[2 - ch];
7bfd22f2 1220 } else {
d802d7ca 1221 gain *= s->dynamic_range[0];
7bfd22f2 1222 }
541d083a
CB
1223 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1224 s->fixed_coeffs[ch], gain, 256);
7bfd22f2 1225 }
d7bcc4ad 1226
ca6e7708 1227 /* apply spectral extension to high frequency bins */
eb0a4d32 1228 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
ca6e7708
CEH
1229 ff_eac3_apply_spectral_extension(s);
1230 }
1231
38dae9c3
JR
1232 /* downmix and MDCT. order depends on whether block switching is used for
1233 any channel in this block. this is because coefficients for the long
1234 and short transforms cannot be mixed. */
1235 downmix_output = s->channels != s->out_channels &&
1236 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1237 s->fbw_channels == s->out_channels);
541d083a 1238 if (different_transforms) {
38dae9c3
JR
1239 /* the delay samples have already been downmixed, so we upmix the delay
1240 samples in order to reconstruct all channels before downmixing. */
541d083a 1241 if (s->downmixed) {
38dae9c3
JR
1242 s->downmixed = 0;
1243 ac3_upmix_delay(s);
1244 }
1245
1246 do_imdct(s, s->channels);
1247
541d083a 1248 if (downmix_output) {
30b39164 1249 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
97cb9236 1250 s->out_channels, s->fbw_channels, 256);
38dae9c3
JR
1251 }
1252 } else {
541d083a 1253 if (downmix_output) {
30b39164 1254 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
97cb9236 1255 s->out_channels, s->fbw_channels, 256);
38dae9c3
JR
1256 }
1257
541d083a 1258 if (downmix_output && !s->downmixed) {
38dae9c3 1259 s->downmixed = 1;
30b39164 1260 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
97cb9236 1261 s->fbw_channels, 128);
38dae9c3 1262 }
486637af 1263
38dae9c3 1264 do_imdct(s, s->out_channels);
3bbb0bf8
JR
1265 }
1266
4e092320 1267 return 0;
486637af
JR
1268}
1269
5066f515
JR
1270/**
1271 * Decode a single AC-3 frame.
c7cfc48f 1272 */
0eea2129
JR
1273static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1274 int *got_frame_ptr, AVPacket *avpkt)
1b293437 1275{
55d2e12a 1276 AVFrame *frame = data;
7a00bbad
TB
1277 const uint8_t *buf = avpkt->data;
1278 int buf_size = avpkt->size;
0345fade 1279 AC3DecodeContext *s = avctx->priv_data;
0eea2129 1280 int blk, ch, err, ret;
95f3019a 1281 const uint8_t *channel_map;
13ec9428 1282 const float *output[AC3_MAX_CHANNELS];
d7bcc4ad 1283
40728b51
JR
1284 /* copy input buffer to decoder context to avoid reading past the end
1285 of the buffer, which can be caused by a damaged input stream. */
4c886d61
RD
1286 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1287 // seems to be byte-swapped AC-3
1288 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1289 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1290 } else
8e33132b 1291 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
67fc8652
JR
1292 buf = s->input_buffer;
1293 /* initialize the GetBitContext with the start of valid AC-3 Frame */
40728b51 1294 init_get_bits(&s->gbc, buf, buf_size * 8);
00585845 1295
5066f515 1296 /* parse the syncinfo */
4397d95c 1297 err = parse_frame_header(s);
c78c6d6c 1298
2c2cdc0b 1299 if (err) {
541d083a
CB
1300 switch (err) {
1301 case AAC_AC3_PARSE_ERROR_SYNC:
1302 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
b1f9cdc3 1303 return AVERROR_INVALIDDATA;
541d083a
CB
1304 case AAC_AC3_PARSE_ERROR_BSID:
1305 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1306 break;
1307 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1308 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1309 break;
1310 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1311 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1312 break;
1313 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1314 /* skip frame if CRC is ok. otherwise use error concealment. */
1315 /* TODO: add support for substreams and dependent frames */
1316 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
818d1f1a 1317 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
541d083a
CB
1318 "skipping frame\n");
1319 *got_frame_ptr = 0;
8f24c12b 1320 return buf_size;
541d083a
CB
1321 } else {
1322 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1323 }
1324 break;
818d1f1a
LB
1325 case AAC_AC3_PARSE_ERROR_CRC:
1326 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
541d083a 1327 break;
818d1f1a
LB
1328 default: // Normal AVERROR do not try to recover.
1329 *got_frame_ptr = 0;
1330 return err;
3df88093 1331 }
2c2cdc0b
JR
1332 } else {
1333 /* check that reported frame size fits in input buffer */
1334 if (s->frame_size > buf_size) {
1335 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1336 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
9abc9873 1337 } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
2c2cdc0b 1338 /* check for crc mismatch */
541d083a
CB
1339 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1340 s->frame_size - 2)) {
2c2cdc0b 1341 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
23a211cb
AK
1342 if (avctx->err_recognition & AV_EF_EXPLODE)
1343 return AVERROR_INVALIDDATA;
2c2cdc0b
JR
1344 err = AAC_AC3_PARSE_ERROR_CRC;
1345 }
1346 }
1b293437 1347 }
2aa2c5c4 1348
eccba2bc
JR
1349 /* if frame is ok, set audio parameters */
1350 if (!err) {
3336110a 1351 avctx->sample_rate = s->sample_rate;
541d083a 1352 avctx->bit_rate = s->bit_rate;
d7c45043 1353 }
3336110a 1354
d7c45043
JR
1355 /* channel config */
1356 if (!err || (s->channels && s->out_channels != s->channels)) {
3336110a 1357 s->out_channels = s->channels;
541d083a
CB
1358 s->output_mode = s->channel_mode;
1359 if (s->lfe_on)
eccba2bc 1360 s->output_mode |= AC3_OUTPUT_LFEON;
b5328546
TW
1361 if (s->channels > 1 &&
1362 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1363 s->out_channels = 1;
1364 s->output_mode = AC3_CHMODE_MONO;
1365 } else if (s->channels > 2 &&
1366 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1367 s->out_channels = 2;
1368 s->output_mode = AC3_CHMODE_STEREO;
3336110a 1369 }
1b293437 1370
3336110a 1371 /* set downmixing coefficients if needed */
541d083a 1372 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
3336110a
JR
1373 s->fbw_channels == s->out_channels)) {
1374 set_downmix_coeffs(s);
1375 }
d7c45043
JR
1376 } else if (!s->channels) {
1377 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1378 return AVERROR_INVALIDDATA;
ecfe94b2 1379 }
d7c45043 1380 avctx->channels = s->out_channels;
48b24bd2
TW
1381 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1382 if (s->output_mode & AC3_OUTPUT_LFEON)
1383 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
d7c45043 1384
be187388
JR
1385 /* set audio service type based on bitstream mode for AC-3 */
1386 avctx->audio_service_type = s->bitstream_mode;
1387 if (s->bitstream_mode == 0x7 && s->channels > 1)
1388 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
f0b3a7ba 1389
0eea2129 1390 /* get output buffer */
031be5b4 1391 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
759001c5 1392 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
0eea2129
JR
1393 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1394 return ret;
1395 }
0eea2129 1396
022845ed 1397 /* decode the audio blocks */
95f3019a 1398 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
ec5da7ae
MR
1399 for (ch = 0; ch < s->channels; ch++) {
1400 if (ch < s->out_channels)
55d2e12a 1401 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
ec5da7ae
MR
1402 else
1403 s->outptr[ch] = s->output[ch];
1404 output[ch] = s->output[ch];
1405 }
6730e9f3 1406 for (blk = 0; blk < s->num_blocks; blk++) {
022845ed
JR
1407 if (!err && decode_audio_block(s, blk)) {
1408 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
af2272b2 1409 err = 1;
1b293437 1410 }
ec5da7ae
MR
1411 if (err)
1412 for (ch = 0; ch < s->out_channels; ch++)
031be5b4 1413 memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
68e57cde 1414 for (ch = 0; ch < s->out_channels; ch++)
ec5da7ae 1415 output[ch] = s->outptr[channel_map[ch]];
6c82c87d 1416 for (ch = 0; ch < s->out_channels; ch++)
68e57cde 1417 s->outptr[ch] += AC3_BLOCK_SIZE;
1b293437 1418 }
0eea2129 1419
ec5da7ae
MR
1420 /* keep last block for error concealment in next frame */
1421 for (ch = 0; ch < s->out_channels; ch++)
031be5b4 1422 memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
ec5da7ae 1423
55d2e12a 1424 *got_frame_ptr = 1;
0eea2129 1425
cc8538ff 1426 return FFMIN(buf_size, s->frame_size);
2aa2c5c4 1427}
1b293437 1428
5066f515
JR
1429/**
1430 * Uninitialize the AC-3 decoder.
c7cfc48f 1431 */
98a6fff9 1432static av_cold int ac3_decode_end(AVCodecContext *avctx)
1b293437 1433{
0345fade 1434 AC3DecodeContext *s = avctx->priv_data;
d802d7ca
JR
1435 ff_mdct_end(&s->imdct_512);
1436 ff_mdct_end(&s->imdct_256);
c7cfc48f 1437
1b293437
JR
1438 return 0;
1439}
1440
9b83919f
AK
1441#define OFFSET(x) offsetof(AC3DecodeContext, x)
1442#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1443static const AVOption options[] = {
c7b610aa 1444 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
9b83919f
AK
1445 { NULL},
1446};
1447
1448static const AVClass ac3_decoder_class = {
a4ea00d0 1449 .class_name = "AC3 decoder",
9b83919f
AK
1450 .item_name = av_default_item_name,
1451 .option = options,
1452 .version = LIBAVUTIL_VERSION_INT,
1453};
1454
d36beb3f 1455AVCodec ff_ac3_decoder = {
541d083a 1456 .name = "ac3",
b2bed932 1457 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
541d083a 1458 .type = AVMEDIA_TYPE_AUDIO,
36ef5369 1459 .id = AV_CODEC_ID_AC3,
e6bca37c 1460 .priv_data_size = sizeof (AC3DecodeContext),
541d083a
CB
1461 .init = ac3_decode_init,
1462 .close = ac3_decode_end,
1463 .decode = ac3_decode_frame,
1464 .capabilities = CODEC_CAP_DR1,
b8f3ab8e 1465 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
541d083a
CB
1466 AV_SAMPLE_FMT_NONE },
1467 .priv_class = &ac3_decoder_class,
2988c93d
JR
1468};
1469
89547cfb 1470#if CONFIG_EAC3_DECODER
a4ea00d0
AK
1471static const AVClass eac3_decoder_class = {
1472 .class_name = "E-AC3 decoder",
1473 .item_name = av_default_item_name,
1474 .option = options,
1475 .version = LIBAVUTIL_VERSION_INT,
1476};
541d083a 1477
d36beb3f 1478AVCodec ff_eac3_decoder = {
541d083a 1479 .name = "eac3",
b2bed932 1480 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
541d083a 1481 .type = AVMEDIA_TYPE_AUDIO,
36ef5369 1482 .id = AV_CODEC_ID_EAC3,
2988c93d 1483 .priv_data_size = sizeof (AC3DecodeContext),
541d083a
CB
1484 .init = ac3_decode_init,
1485 .close = ac3_decode_end,
1486 .decode = ac3_decode_frame,
1487 .capabilities = CODEC_CAP_DR1,
b8f3ab8e 1488 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
541d083a
CB
1489 AV_SAMPLE_FMT_NONE },
1490 .priv_class = &eac3_decoder_class,
1b293437 1491};
89547cfb 1492#endif