ac3dec.c 59.4 KB
Newer Older
1 2
/*
 * AC-3 Audio Decoder
3 4
 * This code was developed as part of Google Summer of Code 2006.
 * E-AC-3 support was added as part of Google Summer of Code 2007.
5
 *
6
 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
7
 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8
 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
9
 *
10
 * This file is part of FFmpeg.
11
 *
12
 * FFmpeg is free software; you can redistribute it and/or
13
 * modify it under the terms of the GNU Lesser General Public
14
 * License as published by the Free Software Foundation; either
15
 * version 2.1 of the License, or (at your option) any later version.
16
 *
17
 * FFmpeg is distributed in the hope that it will be useful,
18 19
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 * Lesser General Public License for more details.
21
 *
22
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with FFmpeg; if not, write to the Free Software
24 25 26 27 28 29 30 31
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <stddef.h>
#include <math.h>
#include <string.h>

32
#include "libavutil/channel_layout.h"
33
#include "libavutil/crc.h"
34
#include "libavutil/downmix_info.h"
35
#include "libavutil/opt.h"
36
#include "internal.h"
37
#include "aac_ac3_parser.h"
38
#include "ac3_parser.h"
39
#include "ac3dec.h"
40
#include "ac3dec_data.h"
41
#include "kbdwin.h"
42

43 44 45 46 47
/**
 * table for ungrouping 3 values in 7 bits.
 * used for exponents and bap=2 mantissas
 */
static uint8_t ungroup_3_in_7_bits_tab[128][3];
48

49
/** tables for ungrouping mantissas */
50 51 52 53 54
static int b1_mantissas[32][3];
static int b2_mantissas[128][3];
static int b3_mantissas[8];
static int b4_mantissas[128][2];
static int b5_mantissas[16];
55

56 57 58 59
/**
 * Quantization table: levels for symmetric. bits for asymmetric.
 * reference: Table 7.18 Mapping of bap to Quantizer
 */
60
static const uint8_t quantization_tab[16] = {
61 62 63
    0, 3, 5, 7, 11, 15,
    5, 6, 7, 8, 9, 10, 11, 12, 14, 16
};
64

65
/** dynamic range table. converts codes to scale factors. */
66
static float dynamic_range_tab[256];
67

68
/** Adjustments in dB gain */
69 70 71
static const float gain_levels[9] = {
    LEVEL_PLUS_3DB,
    LEVEL_PLUS_1POINT5DB,
72
    LEVEL_ONE,
73
    LEVEL_MINUS_1POINT5DB,
74 75 76
    LEVEL_MINUS_3DB,
    LEVEL_MINUS_4POINT5DB,
    LEVEL_MINUS_6DB,
77
    LEVEL_ZERO,
78 79
    LEVEL_MINUS_9DB
};
80

81 82 83 84 85 86 87 88 89
/** Adjustments in dB gain (LFE, +10 to -21 dB) */
static const float gain_levels_lfe[32] = {
    3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
    1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
    0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
    0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
    0.125892, 0.112201, 0.100000, 0.089125
};

90 91 92 93 94
/**
 * Table for default stereo downmixing coefficients
 * reference: Section 7.8.2 Downmixing Into Two Channels
 */
static const uint8_t ac3_default_coeffs[8][5][2] = {
95 96 97 98 99 100 101 102
    { { 2, 7 }, { 7, 2 },                               },
    { { 4, 4 },                                         },
    { { 2, 7 }, { 7, 2 },                               },
    { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
    { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
    { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
103
};
104

105 106 107 108 109
/**
 * Symmetrical Dequantization
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 *            Tables 7.19 to 7.23
 */
110
static inline int
111
symmetric_dequant(int code, int levels)
112
{
113
    return ((code - (levels >> 1)) << 24) / levels;
114 115
}

116 117 118
/*
 * Initialize tables at runtime.
 */
119
static av_cold void ac3_tables_init(void)
120
{
121
    int i;
122

123 124
    /* generate table for ungrouping 3 values in 7 bits
       reference: Section 7.1.3 Exponent Decoding */
125
    for (i = 0; i < 128; i++) {
126 127 128 129 130
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
        ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
    }

131 132
    /* generate grouped mantissa tables
       reference: Section 7.3.5 Ungrouping of Mantissas */
133
    for (i = 0; i < 32; i++) {
134
        /* bap=1 mantissas */
135 136 137
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
138
    }
139
    for (i = 0; i < 128; i++) {
140
        /* bap=2 mantissas */
141 142 143
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
144 145 146 147 148 149 150

        /* bap=4 mantissas */
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
    }
    /* generate ungrouped mantissa tables
       reference: Tables 7.21 and 7.23 */
151
    for (i = 0; i < 7; i++) {
152 153 154
        /* bap=3 mantissas */
        b3_mantissas[i] = symmetric_dequant(i, 7);
    }
155
    for (i = 0; i < 15; i++) {
156 157 158
        /* bap=5 mantissas */
        b5_mantissas[i] = symmetric_dequant(i, 15);
    }
159

160 161
    /* generate dynamic range table
       reference: Section 7.7.1 Dynamic Range Control */
162
    for (i = 0; i < 256; i++) {
163
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
164
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
165
    }
166 167
}

168 169 170
/**
 * AVCodec initialization
 */
171
static av_cold int ac3_decode_init(AVCodecContext *avctx)
172
{
173
    AC3DecodeContext *s = avctx->priv_data;
174 175
    int i;

176
    s->avctx = avctx;
177

178
    ff_ac3_common_init();
179
    ac3_tables_init();
180 181
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
182
    ff_kbd_window_init(s->window, 5.0, 256);
183
    ff_dsputil_init(&s->dsp, avctx);
184
    avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
185
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
186
    ff_fmt_convert_init(&s->fmt_conv, avctx);
187
    av_lfg_init(&s->dith_state, 0);
188

189
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
190

191
    /* allow downmixing to stereo or mono */
192 193 194 195 196 197 198 199 200 201 202 203 204 205
#if FF_API_REQUEST_CHANNELS
FF_DISABLE_DEPRECATION_WARNINGS
    if (avctx->request_channels == 1)
        avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
    else if (avctx->request_channels == 2)
        avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
    if (avctx->channels > 1 &&
        avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
        avctx->channels = 1;
    else if (avctx->channels > 2 &&
             avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
        avctx->channels = 2;
206
    s->downmixed = 1;
207

208 209 210 211 212
    for (i = 0; i < AC3_MAX_CHANNELS; i++) {
        s->xcfptr[i] = s->transform_coeffs[i];
        s->dlyptr[i] = s->delay[i];
    }

213
    return 0;
214 215
}

216
/**
217
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
218
 * GetBitContext within AC3DecodeContext must point to
219
 * the start of the synchronized AC-3 bitstream.
220
 */
221
static int ac3_parse_header(AC3DecodeContext *s)
222 223 224 225 226
{
    GetBitContext *gbc = &s->gbc;
    int i;

    /* read the rest of the bsi. read twice for dual mono mode. */
227
    i = !s->channel_mode;
228 229 230 231 232 233 234 235 236 237 238 239
    do {
        skip_bits(gbc, 5); // skip dialog normalization
        if (get_bits1(gbc))
            skip_bits(gbc, 8); //skip compression
        if (get_bits1(gbc))
            skip_bits(gbc, 8); //skip language code
        if (get_bits1(gbc))
            skip_bits(gbc, 7); //skip audio production information
    } while (i--);

    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit

240
    /* skip the timecodes or parse the Alternate Bit Stream Syntax */
241 242 243 244 245 246
    if (s->bitstream_id != 6) {
        if (get_bits1(gbc))
            skip_bits(gbc, 14); //skip timecode1
        if (get_bits1(gbc))
            skip_bits(gbc, 14); //skip timecode2
    } else {
247 248 249
        if (get_bits1(gbc)) {
            s->preferred_downmix       = get_bits(gbc, 2);
            s->center_mix_level_ltrt   = get_bits(gbc, 3);
250
            s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
251
            s->center_mix_level        = get_bits(gbc, 3);
252
            s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
253
        }
254 255 256 257 258 259
        if (get_bits1(gbc)) {
            s->dolby_surround_ex_mode = get_bits(gbc, 2);
            s->dolby_headphone_mode   = get_bits(gbc, 2);
            skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
        }
    }
260 261 262 263 264 265

    /* skip additional bitstream info */
    if (get_bits1(gbc)) {
        i = get_bits(gbc, 6);
        do {
            skip_bits(gbc, 8);
266
        } while (i--);
267 268 269 270 271 272
    }

    return 0;
}

/**
273
 * Common function to parse AC-3 or E-AC-3 frame header
274 275
 */
static int parse_frame_header(AC3DecodeContext *s)
276
{
277
    AC3HeaderInfo hdr;
278
    int err;
279

280
    err = avpriv_ac3_parse_header(&s->gbc, &hdr);
281
    if (err)
282 283 284
        return err;

    /* get decoding parameters from header info */
285
    s->bit_alloc_params.sr_code     = hdr.sr_code;
286
    s->bitstream_id                 = hdr.bitstream_id;
287
    s->bitstream_mode               = hdr.bitstream_mode;
288
    s->channel_mode                 = hdr.channel_mode;
289
    s->lfe_on                       = hdr.lfe_on;
290
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
291
    s->sample_rate                  = hdr.sample_rate;
292 293 294 295 296
    s->bit_rate                     = hdr.bit_rate;
    s->channels                     = hdr.channels;
    s->fbw_channels                 = s->channels - s->lfe_on;
    s->lfe_ch                       = s->fbw_channels + 1;
    s->frame_size                   = hdr.frame_size;
297
    s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
298
    s->center_mix_level             = hdr.center_mix_level;
299
    s->center_mix_level_ltrt        = 4; // -3.0dB
300
    s->surround_mix_level           = hdr.surround_mix_level;
301 302
    s->surround_mix_level_ltrt      = 4; // -3.0dB
    s->lfe_mix_level_exists         = 0;
303
    s->num_blocks                   = hdr.num_blocks;
304
    s->frame_type                   = hdr.frame_type;
305
    s->substreamid                  = hdr.substreamid;
306
    s->dolby_surround_mode          = hdr.dolby_surround_mode;
307 308
    s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
    s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
309

310 311 312
    if (s->lfe_on) {
        s->start_freq[s->lfe_ch]     = 0;
        s->end_freq[s->lfe_ch]       = 7;
313 314 315 316
        s->num_exp_groups[s->lfe_ch] = 2;
        s->channel_in_cpl[s->lfe_ch] = 0;
    }

317
    if (s->bitstream_id <= 10) {
318 319 320 321 322 323 324 325 326 327
        s->eac3                  = 0;
        s->snr_offset_strategy   = 2;
        s->block_switch_syntax   = 1;
        s->dither_flag_syntax    = 1;
        s->bit_allocation_syntax = 1;
        s->fast_gain_syntax      = 0;
        s->first_cpl_leak        = 0;
        s->dba_syntax            = 1;
        s->skip_syntax           = 1;
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
Justin Ruggles's avatar
Justin Ruggles committed
328
        return ac3_parse_header(s);
329
    } else if (CONFIG_EAC3_DECODER) {
330 331
        s->eac3 = 1;
        return ff_eac3_parse_header(s);
332 333
    } else {
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
334
        return AVERROR(ENOSYS);
335
    }
336 337 338 339 340 341 342 343 344
}

/**
 * Set stereo downmixing coefficients based on frame header info.
 * reference: Section 7.8.2 Downmixing Into Two Channels
 */
static void set_downmix_coeffs(AC3DecodeContext *s)
{
    int i;
345 346
    float cmix = gain_levels[s->  center_mix_level];
    float smix = gain_levels[s->surround_mix_level];
Loren Merritt's avatar
Loren Merritt committed
347
    float norm0, norm1;
348

349
    for (i = 0; i < s->fbw_channels; i++) {
350 351
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
352
    }
353
    if (s->channel_mode > 1 && s->channel_mode & 1) {
354
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
355
    }
356
    if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
357
        int nf = s->channel_mode - 2;
358
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
359
    }
360
    if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
361
        int nf = s->channel_mode - 4;
362
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
363
    }
364

Loren Merritt's avatar
Loren Merritt committed
365 366
    /* renormalize */
    norm0 = norm1 = 0.0;
367
    for (i = 0; i < s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
368 369 370 371 372
        norm0 += s->downmix_coeffs[i][0];
        norm1 += s->downmix_coeffs[i][1];
    }
    norm0 = 1.0f / norm0;
    norm1 = 1.0f / norm1;
373
    for (i = 0; i < s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
374 375 376 377
        s->downmix_coeffs[i][0] *= norm0;
        s->downmix_coeffs[i][1] *= norm1;
    }

378 379 380 381
    if (s->output_mode == AC3_CHMODE_MONO) {
        for (i = 0; i < s->fbw_channels; i++)
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
                                       s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
382
    }
383 384
}

385
/**
386 387
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
388
 */
389
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
390
                            uint8_t absexp, int8_t *dexps)
391
{
392
    int i, j, grp, group_size;
393 394 395 396
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
397
    group_size = exp_strategy + (exp_strategy == EXP_D45);
398
    for (grp = 0, i = 0; grp < ngrps; grp++) {
399
        expacc = get_bits(gbc, 7);
400 401 402
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
403
    }
404

405 406
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
407
    for (i = 0, j = 0; i < ngrps * 3; i++) {
408
        prevexp += dexp[i] - 2;
409
        if (prevexp > 24U)
410
            return -1;
411
        switch (group_size) {
412 413 414 415
        case 4: dexps[j++] = prevexp;
                dexps[j++] = prevexp;
        case 2: dexps[j++] = prevexp;
        case 1: dexps[j++] = prevexp;
416
        }
417
    }
418
    return 0;
419 420
}

421
/**
422
 * Generate transform coefficients for each coupled channel in the coupling
423 424 425
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
426
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
427
{
428
    int bin, band, ch;
429 430 431

    bin = s->start_freq[CPL_CH];
    for (band = 0; band < s->num_cpl_bands; band++) {
432
        int band_start = bin;
433
        int band_end = bin + s->cpl_band_sizes[band];
434 435
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (s->channel_in_cpl[ch]) {
436
                int cpl_coord = s->cpl_coords[ch][band] << 5;
437
                for (bin = band_start; bin < band_end; bin++) {
438 439
                    s->fixed_coeffs[ch][bin] =
                        MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
440 441 442 443
                }
                if (ch == 2 && s->phase_flags[band]) {
                    for (bin = band_start; bin < band_end; bin++)
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
444
                }
445
            }
446
        }
447
        bin = band_end;
448 449 450
    }
}

451 452 453 454
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
typedef struct {
455 456 457 458 459 460
    int b1_mant[2];
    int b2_mant[2];
    int b4_mant;
    int b1;
    int b2;
    int b4;
461 462
} mant_groups;

463
/**
464
 * Decode the transform coefficients for a particular channel
465 466
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
467
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
468
{
469
    int start_freq = s->start_freq[ch_index];
470 471 472
    int end_freq   = s->end_freq[ch_index];
    uint8_t *baps  = s->bap[ch_index];
    int8_t *exps   = s->dexps[ch_index];
473
    int32_t *coeffs = s->fixed_coeffs[ch_index];
474
    int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
475
    GetBitContext *gbc = &s->gbc;
476
    int freq;
477

478
    for (freq = start_freq; freq < end_freq; freq++) {
479 480
        int bap = baps[freq];
        int mantissa;
481 482
        switch (bap) {
        case 0:
483
            /* random noise with approximate range of -0.707 to 0.707 */
484
            if (dither)
485
                mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
            else
                mantissa = 0;
            break;
        case 1:
            if (m->b1) {
                m->b1--;
                mantissa = m->b1_mant[m->b1];
            } else {
                int bits      = get_bits(gbc, 5);
                mantissa      = b1_mantissas[bits][0];
                m->b1_mant[1] = b1_mantissas[bits][1];
                m->b1_mant[0] = b1_mantissas[bits][2];
                m->b1         = 2;
            }
            break;
        case 2:
            if (m->b2) {
                m->b2--;
                mantissa = m->b2_mant[m->b2];
            } else {
                int bits      = get_bits(gbc, 7);
                mantissa      = b2_mantissas[bits][0];
                m->b2_mant[1] = b2_mantissas[bits][1];
                m->b2_mant[0] = b2_mantissas[bits][2];
                m->b2         = 2;
            }
            break;
        case 3:
            mantissa = b3_mantissas[get_bits(gbc, 3)];
            break;
        case 4:
            if (m->b4) {
                m->b4 = 0;
                mantissa = m->b4_mant;
            } else {
                int bits   = get_bits(gbc, 7);
                mantissa   = b4_mantissas[bits][0];
                m->b4_mant = b4_mantissas[bits][1];
                m->b4      = 1;
            }
            break;
        case 5:
            mantissa = b5_mantissas[get_bits(gbc, 4)];
            break;
        default: /* 6 to 15 */
            /* Shift mantissa and sign-extend it. */
532 533 534 535
            if (bap > 15) {
                av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
                bap = 15;
            }
536 537 538
            mantissa = get_sbits(gbc, quantization_tab[bap]);
            mantissa <<= 24 - quantization_tab[bap];
            break;
539
        }
540
        coeffs[freq] = mantissa >> exps[freq];
541 542 543
    }
}

544
/**
545 546
 * Remove random dithering from coupling range coefficients with zero-bit
 * mantissas for coupled channels which do not use dithering.
547 548
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
549
static void remove_dithering(AC3DecodeContext *s) {
550 551
    int ch, i;

552 553 554 555
    for (ch = 1; ch <= s->fbw_channels; ch++) {
        if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
            for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
                if (!s->bap[CPL_CH][i])
556
                    s->fixed_coeffs[ch][i] = 0;
557 558 559 560 561
            }
        }
    }
}

562
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
563
                                       mant_groups *m)
564 565
{
    if (!s->channel_uses_aht[ch]) {
566
        ac3_decode_transform_coeffs_ch(s, ch, m);
567 568 569 570
    } else {
        /* if AHT is used, mantissas for all blocks are encoded in the first
           block of the frame. */
        int bin;
571
        if (!blk && CONFIG_EAC3_DECODER)
572
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
573
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
574
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
575 576 577 578
        }
    }
}

579
/**
580
 * Decode the transform coefficients.
581
 */
582
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
583
{
584
    int ch, end;
585
    int got_cplchan = 0;
586 587
    mant_groups m;

588
    m.b1 = m.b2 = m.b4 = 0;
589

590
    for (ch = 1; ch <= s->channels; ch++) {
591
        /* transform coefficients for full-bandwidth channel */
592
        decode_transform_coeffs_ch(s, blk, ch, &m);
Diego Biurrun's avatar
Diego Biurrun committed
593
        /* transform coefficients for coupling channel come right after the
594
           coefficients for the first coupled channel*/
595
        if (s->channel_in_cpl[ch])  {
596
            if (!got_cplchan) {
597
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
598
                calc_transform_coeffs_cpl(s);
599 600
                got_cplchan = 1;
            }
601
            end = s->end_freq[CPL_CH];
602
        } else {
603
            end = s->end_freq[ch];
604
        }
605
        do
606
            s->fixed_coeffs[ch][end] = 0;
607
        while (++end < 256);
608
    }
609

610
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
611
    remove_dithering(s);
612 613
}

614
/**
615
 * Stereo rematrixing.
616 617
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
618
static void do_rematrixing(AC3DecodeContext *s)
619
{
620
    int bnd, i;
621 622
    int end, bndend;

623
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
624

625 626 627 628
    for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
        if (s->rematrixing_flags[bnd]) {
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
            for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
629
                int tmp0 = s->fixed_coeffs[1][i];
630
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
631
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
632 633
            }
        }
634 635
    }
}
636

637 638 639 640 641
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
642
static inline void do_imdct(AC3DecodeContext *s, int channels)
643
{
Justin Ruggles's avatar
Justin Ruggles committed
644
    int ch;
645

646
    for (ch = 1; ch <= channels; ch++) {
647
        if (s->block_switch[ch]) {
Loren Merritt's avatar
Loren Merritt committed
648
            int i;
649 650 651
            float *x = s->tmp_output + 128;
            for (i = 0; i < 128; i++)
                x[i] = s->transform_coeffs[ch][2 * i];
652
            s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
653 654
            s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
                                       s->tmp_output, s->window, 128);
655 656 657
            for (i = 0; i < 128; i++)
                x[i] = s->transform_coeffs[ch][2 * i + 1];
            s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
658
        } else {
659
            s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
660 661
            s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
                                       s->tmp_output, s->window, 128);
662
            memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
663
        }
664 665 666
    }
}

667 668 669 670 671
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
672
    int channel_data_size = sizeof(s->delay[0]);
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
    switch (s->channel_mode) {
    case AC3_CHMODE_DUALMONO:
    case AC3_CHMODE_STEREO:
        /* upmix mono to stereo */
        memcpy(s->delay[1], s->delay[0], channel_data_size);
        break;
    case AC3_CHMODE_2F2R:
        memset(s->delay[3], 0, channel_data_size);
    case AC3_CHMODE_2F1R:
        memset(s->delay[2], 0, channel_data_size);
        break;
    case AC3_CHMODE_3F2R:
        memset(s->delay[4], 0, channel_data_size);
    case AC3_CHMODE_3F1R:
        memset(s->delay[3], 0, channel_data_size);
    case AC3_CHMODE_3F:
        memcpy(s->delay[2], s->delay[1], channel_data_size);
        memset(s->delay[1], 0, channel_data_size);
        break;
692 693 694
    }
}

695 696
/**
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
697 698 699 700
 * The band structure defines how many subbands are in each band.  For each
 * subband in the range, 1 means it is combined with the previous band, and 0
 * means that it starts a new band.
 *
701 702 703 704 705 706 707 708 709 710 711 712 713
 * @param[in] gbc bit reader context
 * @param[in] blk block number
 * @param[in] eac3 flag to indicate E-AC-3
 * @param[in] ecpl flag to indicate enhanced coupling
 * @param[in] start_subband subband number for start of range
 * @param[in] end_subband subband number for end of range
 * @param[in] default_band_struct default band structure table
 * @param[out] num_bands number of bands (optionally NULL)
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
 */
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
                                  int ecpl, int start_subband, int end_subband,
                                  const uint8_t *default_band_struct,
714
                                  int *num_bands, uint8_t *band_sizes)
715
{
716
    int subbnd, bnd, n_subbands, n_bands=0;
717
    uint8_t bnd_sz[22];
718 719
    uint8_t coded_band_struct[22];
    const uint8_t *band_struct;
720 721 722 723 724 725

    n_subbands = end_subband - start_subband;

    /* decode band structure from bitstream or use default */
    if (!eac3 || get_bits1(gbc)) {
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
726
            coded_band_struct[subbnd] = get_bits1(gbc);
727
        }
728
        band_struct = coded_band_struct;
729
    } else if (!blk) {
730 731 732 733
        band_struct = &default_band_struct[start_subband+1];
    } else {
        /* no change in band structure */
        return;
734 735 736 737 738 739
    }

    /* calculate number of bands and band sizes based on band structure.
       note that the first 4 subbands in enhanced coupling span only 6 bins
       instead of 12. */
    if (num_bands || band_sizes ) {
740
        n_bands = n_subbands;
741 742 743
        bnd_sz[0] = ecpl ? 6 : 12;
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
744
            if (band_struct[subbnd - 1]) {
745 746 747 748 749 750 751 752 753 754 755 756
                n_bands--;
                bnd_sz[bnd] += subbnd_size;
            } else {
                bnd_sz[++bnd] = subbnd_size;
            }
        }
    }

    /* set optional output params */
    if (num_bands)
        *num_bands = n_bands;
    if (band_sizes)
757
        memcpy(band_sizes, bnd_sz, n_bands);
758 759
}

760
/**
761
 * Decode a single audio block from the AC-3 bitstream.
762
 */
763
static int decode_audio_block(AC3DecodeContext *s, int blk)
764
{
765 766
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
767
    int i, bnd, seg, ch;
768 769
    int different_transforms;
    int downmix_output;
770
    int cpl_in_use;
771
    GetBitContext *gbc = &s->gbc;
772
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
773

774
    /* block switch flags */
775
    different_transforms = 0;
776
    if (s->block_switch_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
777 778
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->block_switch[ch] = get_bits1(gbc);
779
            if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
Justin Ruggles's avatar
Justin Ruggles committed
780 781
                different_transforms = 1;
        }
782
    }
783

784
    /* dithering flags */
785
    if (s->dither_flag_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
786 787 788
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->dither_flag[ch] = get_bits1(gbc);
        }
789
    }
790

791
    /* dynamic range */
792
    i = !s->channel_mode;
793
    do {
794
        if (get_bits1(gbc)) {
795 796 797 798 799 800 801
            /* Allow asymmetric application of DRC when drc_scale > 1.
               Amplification of quiet sounds is enhanced */
            float range = dynamic_range_tab[get_bits(gbc, 8)];
            if (range > 1.0 || s->drc_scale <= 1.0)
                s->dynamic_range[i] = powf(range, s->drc_scale);
            else
                s->dynamic_range[i] = range;
802
        } else if (blk == 0) {
803
            s->dynamic_range[i] = 1.0f;
804
        }
805
    } while (i--);
806

807 808
    /* spectral extension strategy */
    if (s->eac3 && (!blk || get_bits1(gbc))) {
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838
        s->spx_in_use = get_bits1(gbc);
        if (s->spx_in_use) {
            int dst_start_freq, dst_end_freq, src_start_freq,
                start_subband, end_subband;

            /* determine which channels use spx */
            if (s->channel_mode == AC3_CHMODE_MONO) {
                s->channel_uses_spx[1] = 1;
            } else {
                for (ch = 1; ch <= fbw_channels; ch++)
                    s->channel_uses_spx[ch] = get_bits1(gbc);
            }

            /* get the frequency bins of the spx copy region and the spx start
               and end subbands */
            dst_start_freq = get_bits(gbc, 2);
            start_subband  = get_bits(gbc, 3) + 2;
            if (start_subband > 7)
                start_subband += start_subband - 7;
            end_subband    = get_bits(gbc, 3) + 5;
            if (end_subband   > 7)
                end_subband   += end_subband   - 7;
            dst_start_freq = dst_start_freq * 12 + 25;
            src_start_freq = start_subband  * 12 + 25;
            dst_end_freq   = end_subband    * 12 + 25;

            /* check validity of spx ranges */
            if (start_subband >= end_subband) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
                       "range (%d >= %d)\n", start_subband, end_subband);
839
                return AVERROR_INVALIDDATA;
840 841 842 843
            }
            if (dst_start_freq >= src_start_freq) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
                       "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
844
                return AVERROR_INVALIDDATA;
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
            }

            s->spx_dst_start_freq = dst_start_freq;
            s->spx_src_start_freq = src_start_freq;
            s->spx_dst_end_freq   = dst_end_freq;

            decode_band_structure(gbc, blk, s->eac3, 0,
                                  start_subband, end_subband,
                                  ff_eac3_default_spx_band_struct,
                                  &s->num_spx_bands,
                                  s->spx_band_sizes);
        } else {
            for (ch = 1; ch <= fbw_channels; ch++) {
                s->channel_uses_spx[ch] = 0;
                s->first_spx_coords[ch] = 1;
            }
861 862 863
        }
    }

864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
    /* spectral extension coordinates */
    if (s->spx_in_use) {
        for (ch = 1; ch <= fbw_channels; ch++) {
            if (s->channel_uses_spx[ch]) {
                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
                    float spx_blend;
                    int bin, master_spx_coord;

                    s->first_spx_coords[ch] = 0;
                    spx_blend = get_bits(gbc, 5) * (1.0f/32);
                    master_spx_coord = get_bits(gbc, 2) * 3;

                    bin = s->spx_src_start_freq;
                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
                        int bandsize;
                        int spx_coord_exp, spx_coord_mant;
                        float nratio, sblend, nblend, spx_coord;

                        /* calculate blending factors */
                        bandsize = s->spx_band_sizes[bnd];
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
886 887
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
                                                       // to give unity variance
888 889 890 891 892 893 894 895 896
                        sblend = sqrtf(1.0f - nratio);
                        bin += bandsize;

                        /* decode spx coordinates */
                        spx_coord_exp  = get_bits(gbc, 4);
                        spx_coord_mant = get_bits(gbc, 2);
                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
                        else                     spx_coord_mant += 4;
                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
897
                        spx_coord = spx_coord_mant * (1.0f / (1 << 23));
898 899 900 901 902 903 904 905 906 907 908

                        /* multiply noise and signal blending factors by spx coordinate */
                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
                    }
                }
            } else {
                s->first_spx_coords[ch] = 1;
            }
        }
    }
909

910
    /* coupling strategy */
911
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
912
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
913
        if (!s->eac3)
Justin Ruggles's avatar
Justin Ruggles committed
914
            s->cpl_in_use[blk] = get_bits1(gbc);
915
        if (s->cpl_in_use[blk]) {
916
            /* coupling in use */
917
            int cpl_start_subband, cpl_end_subband;
918

919 920
            if (channel_mode < AC3_CHMODE_STEREO) {
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
921
                return AVERROR_INVALIDDATA;
922 923
            }

924 925 926
            /* check for enhanced coupling */
            if (s->eac3 && get_bits1(gbc)) {
                /* TODO: parse enhanced coupling strategy info */
927
                avpriv_request_sample(s->avctx, "Enhanced coupling");
928
                return AVERROR_PATCHWELCOME;
929 930
            }

931
            /* determine which channels are coupled */
932 933 934 935
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
                s->channel_in_cpl[1] = 1;
                s->channel_in_cpl[2] = 1;
            } else {
Justin Ruggles's avatar
Justin Ruggles committed
936 937
                for (ch = 1; ch <= fbw_channels; ch++)
                    s->channel_in_cpl[ch] = get_bits1(gbc);
938
            }
939

940
            /* phase flags in use */
941
            if (channel_mode == AC3_CHMODE_STEREO)
942
                s->phase_flags_in_use = get_bits1(gbc);
943

944
            /* coupling frequency range */
945
            cpl_start_subband = get_bits(gbc, 4);
946 947
            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
                                              get_bits(gbc, 4) + 3;
948 949
            if (cpl_start_subband >= cpl_end_subband) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
950
                       cpl_start_subband, cpl_end_subband);
951
                return AVERROR_INVALIDDATA;
952
            }
953
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
954
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
955

956 957 958
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
                                  cpl_end_subband,
                                  ff_eac3_default_cpl_band_struct,
959
                                  &s->num_cpl_bands, s->cpl_band_sizes);
960
        } else {
961
            /* coupling not in use */
962
            for (ch = 1; ch <= fbw_channels; ch++) {
963
                s->channel_in_cpl[ch] = 0;
964 965
                s->first_cpl_coords[ch] = 1;
            }
966
            s->first_cpl_leak = s->eac3;
967
            s->phase_flags_in_use = 0;
968
        }
969
    } else if (!s->eac3) {
970 971 972
        if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
                   "be present in block 0\n");
973
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
974 975 976
        } else {
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
        }
977
    }
978
    cpl_in_use = s->cpl_in_use[blk];
979

980
    /* coupling coordinates */
981
    if (cpl_in_use) {
982
        int cpl_coords_exist = 0;
983

984
        for (ch = 1; ch <= fbw_channels; ch++) {
985
            if (s->channel_in_cpl[ch]) {
986
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
987
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
988
                    s->first_cpl_coords[ch] = 0;
989
                    cpl_coords_exist = 1;
990
                    master_cpl_coord = 3 * get_bits(gbc, 2);
991
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
992 993
                        cpl_coord_exp = get_bits(gbc, 4);
                        cpl_coord_mant = get_bits(gbc, 4);
994
                        if (cpl_coord_exp == 15)
995
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
996
                        else
997 998
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
999
                    }
1000
                } else if (!blk) {
1001 1002
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
                           "be present in block 0\n");
1003
                    return AVERROR_INVALIDDATA;
1004
                }
1005 1006 1007
            } else {
                /* channel not in coupling */
                s->first_cpl_coords[ch] = 1;
1008 1009
            }
        }
1010
        /* phase flags */
1011
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1012
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1013
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1014 1015
            }
        }
1016
    }
1017

1018
    /* stereo rematrixing strategy and band structure */
1019
    if (channel_mode == AC3_CHMODE_STEREO) {
1020
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1021
            s->num_rematrixing_bands = 4;
1022
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1023
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1024 1025 1026
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
                s->num_rematrixing_bands--;
            }
1027
            for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1028
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1029
        } else if (!blk) {
1030 1031
            av_log(s->avctx, AV_LOG_WARNING, "Warning: "
                   "new rematrixing strategy not present in block 0\n");
1032
            s->num_rematrixing_bands = 0;
1033
        }
1034 1035
    }

1036
    /* exponent strategies for each channel */
1037
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1038
        if (!s->eac3)
1039
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1040
        if (s->exp_strategy[blk][ch] != EXP_REUSE)
1041 1042 1043
            bit_alloc_stages[ch] = 3;
    }

1044
    /* channel bandwidth */
1045
    for (ch = 1; ch <= fbw_channels; ch++) {
1046
        s->start_freq[ch] = 0;
1047
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1048
            int group_size;
1049 1050 1051
            int prev = s->end_freq[ch];
            if (s->channel_in_cpl[ch])
                s->end_freq[ch] = s->start_freq[CPL_CH];
1052 1053
            else if (s->channel_uses_spx[ch])
                s->end_freq[ch] = s->spx_src_start_freq;
1054
            else {
1055
                int bandwidth_code = get_bits(gbc, 6);
1056
                if (bandwidth_code > 60) {
1057
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1058
                    return AVERROR_INVALIDDATA;
1059
                }
1060
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1061
            }
1062
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1063 1064
            s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
            if (blk > 0 && s->end_freq[ch] != prev)
1065
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1066
        }
1067
    }
1068
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1069
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1070
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1071
    }
1072

1073
    /* decode exponents for each channel */
1074
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1075
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1076
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1077
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1078 1079
                                 s->num_exp_groups[ch], s->dexps[ch][0],
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1080
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1081
                return AVERROR_INVALIDDATA;
1082
            }
1083
            if (ch != CPL_CH && ch != s->lfe_ch)
1084
                skip_bits(gbc, 2); /* skip gainrng */
1085
        }
1086
    }
1087

1088
    /* bit allocation information */
1089
    if (s->bit_allocation_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
1090 1091 1092 1093 1094
        if (get_bits1(gbc)) {
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1095
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1096
            for (ch = !cpl_in_use; ch <= s->channels; ch++)
Justin Ruggles's avatar
Justin Ruggles committed
1097 1098
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
        } else if (!blk) {
1099 1100
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
                   "be present in block 0\n");
1101
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1102
        }
1103
    }
1104

1105
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1106 1107
    if (!s->eac3 || !blk) {
        if (s->snr_offset_strategy && get_bits1(gbc)) {
Justin Ruggles's avatar
Justin Ruggles committed
1108 1109 1110 1111 1112 1113 1114 1115
            int snr = 0;
            int csnr;
            csnr = (get_bits(gbc, 6) - 15) << 4;
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
                /* snr offset */
                if (ch == i || s->snr_offset_strategy == 2)
                    snr = (csnr + get_bits(gbc, 4)) << 2;
                /* run at least last bit allocation stage if snr offset changes */
1116
                if (blk && s->snr_offset[ch] != snr) {
Justin Ruggles's avatar
Justin Ruggles committed
1117 1118 1119
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
                }
                s->snr_offset[ch] = snr;
1120 1121 1122 1123

                /* fast gain (normal AC-3 only) */
                if (!s->eac3) {
                    int prev = s->fast_gain[ch];
Justin Ruggles's avatar
Justin Ruggles committed
1124
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1125
                    /* run last 2 bit allocation stages if fast gain changes */
1126
                    if (blk && prev != s->fast_gain[ch])
1127 1128
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
                }
Justin Ruggles's avatar
Justin Ruggles committed
1129
            }
1130
        } else if (!s->eac3 && !blk) {
Justin Ruggles's avatar
Justin Ruggles committed
1131
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1132
            return AVERROR_INVALIDDATA;
1133
        }
1134
    }
1135

1136 1137 1138 1139 1140 1141
    /* fast gain (E-AC-3 only) */
    if (s->fast_gain_syntax && get_bits1(gbc)) {
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
            int prev = s->fast_gain[ch];
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
            /* run last 2 bit allocation stages if fast gain changes */
1142
            if (blk && prev != s->fast_gain[ch])
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
        }
    } else if (s->eac3 && !blk) {
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
    }

    /* E-AC-3 to AC-3 converter SNR offset */
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
        skip_bits(gbc, 10); // skip converter snr offset
    }

1155
    /* coupling leak information */
1156
    if (cpl_in_use) {
1157 1158 1159 1160 1161
        if (s->first_cpl_leak || get_bits1(gbc)) {
            int fl = get_bits(gbc, 3);
            int sl = get_bits(gbc, 3);
            /* run last 2 bit allocation stages for coupling channel if
               coupling leak changes */
1162 1163
            if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
                sl != s->bit_alloc_params.cpl_slow_leak)) {
Justin Ruggles's avatar
Justin Ruggles committed
1164
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1165 1166 1167 1168
            }
            s->bit_alloc_params.cpl_fast_leak = fl;
            s->bit_alloc_params.cpl_slow_leak = sl;
        } else if (!s->eac3 && !blk) {
1169 1170
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
                   "be present in block 0\n");
1171
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1172
        }
1173
        s->first_cpl_leak = 0;
1174
    }
1175

1176
    /* delta bit allocation information */
1177
    if (s->dba_syntax && get_bits1(gbc)) {
1178
        /* delta bit allocation exists (strategy) */
1179
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1180 1181 1182
            s->dba_mode[ch] = get_bits(gbc, 2);
            if (s->dba_mode[ch] == DBA_RESERVED) {
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1183
                return AVERROR_INVALIDDATA;
1184
            }
1185
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1186
        }
1187
        /* channel delta offset, len and bit allocation */
1188
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1189
            if (s->dba_mode[ch] == DBA_NEW) {
1190 1191
                s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
                for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1192 1193
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1194
                    s->dba_values[ch][seg]  = get_bits(gbc, 3);
1195
                }
1196 1197
                /* run last 2 bit allocation stages if new dba values */
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1198
            }
1199
        }
1200 1201
    } else if (blk == 0) {
        for (ch = 0; ch <= s->channels; ch++) {
1202
            s->dba_mode[ch] = DBA_NONE;
1203
        }
1204
    }
1205

1206
    /* Bit allocation */
1207 1208
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
        if (bit_alloc_stages[ch] > 2) {
1209
            /* Exponent mapping into PSD and PSD integration */
1210 1211 1212
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->psd[ch], s->band_psd[ch]);
1213
        }
1214
        if (bit_alloc_stages[ch] > 1) {
1215 1216
            /* Compute excitation function, Compute masking curve, and
               Apply delta bit allocation */
1217
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1218 1219 1220
                                           s->start_freq[ch],  s->end_freq[ch],
                                           s->fast_gain[ch],   (ch == s->lfe_ch),
                                           s->dba_mode[ch],    s->dba_nsegs[ch],
1221
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1222
                                           s->dba_values[ch],  s->mask[ch])) {
1223
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1224
                return AVERROR_INVALIDDATA;
1225
            }
1226
        }
1227
        if (bit_alloc_stages[ch] > 0) {
1228
            /* Compute bit allocation */
1229 1230
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1231
            s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1232 1233 1234
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->snr_offset[ch],
                                      s->bit_alloc_params.floor,
1235
                                      bap_tab, s->bap[ch]);
1236
        }
1237
    }
1238

1239
    /* unused dummy data */
1240
    if (s->skip_syntax && get_bits1(gbc)) {
1241
        int skipl = get_bits(gbc, 9);
1242
        while (skipl--)
1243
            skip_bits(gbc, 8);
1244
    }
1245

1246
    /* unpack the transform coefficients
1247
       this also uncouples channels if coupling is in use. */
1248
    decode_transform_coeffs(s, blk);
1249

1250 1251
    /* TODO: generate enhanced coupling coordinates and uncouple */

1252
    /* recover coefficients if rematrixing is in use */
1253
    if (s->channel_mode == AC3_CHMODE_STEREO)
1254
        do_rematrixing(s);
1255

1256
    /* apply scaling to coefficients (headroom, dynrng) */
1257
    for (ch = 1; ch <= s->channels; ch++) {
1258
        float gain = 1.0 / 4194304.0f;
1259 1260
        if (s->channel_mode == AC3_CHMODE_DUALMONO) {
            gain *= s->dynamic_range[2 - ch];
1261
        } else {
1262
            gain *= s->dynamic_range[0];
1263
        }
1264 1265
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
                                               s->fixed_coeffs[ch], gain, 256);
1266
    }
1267

1268
    /* apply spectral extension to high frequency bins */
1269
    if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1270 1271 1272
        ff_eac3_apply_spectral_extension(s);
    }

1273 1274 1275 1276 1277 1278
    /* downmix and MDCT. order depends on whether block switching is used for
       any channel in this block. this is because coefficients for the long
       and short transforms cannot be mixed. */
    downmix_output = s->channels != s->out_channels &&
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
                     s->fbw_channels == s->out_channels);
1279
    if (different_transforms) {
1280 1281
        /* the delay samples have already been downmixed, so we upmix the delay
           samples in order to reconstruct all channels before downmixing. */
1282
        if (s->downmixed) {
1283 1284 1285 1286 1287 1288
            s->downmixed = 0;
            ac3_upmix_delay(s);
        }

        do_imdct(s, s->channels);

1289
        if (downmix_output) {
1290
            s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1291
                              s->out_channels, s->fbw_channels, 256);
1292 1293
        }
    } else {
1294
        if (downmix_output) {
1295
            s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1296
                              s->out_channels, s->fbw_channels, 256);
1297 1298
        }

1299
        if (downmix_output && !s->downmixed) {
1300
            s->downmixed = 1;
1301
            s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1302
                              s->fbw_channels, 128);
1303
        }
1304

1305
        do_imdct(s, s->out_channels);
1306 1307
    }

1308
    return 0;
1309 1310
}

1311 1312
/**
 * Decode a single AC-3 frame.
1313
 */
1314 1315
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
                            int *got_frame_ptr, AVPacket *avpkt)
1316
{
1317
    AVFrame *frame     = data;
1318 1319
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
1320
    AC3DecodeContext *s = avctx->priv_data;
1321
    int blk, ch, err, ret;
1322
    const uint8_t *channel_map;
1323
    const float *output[AC3_MAX_CHANNELS];
1324
    enum AVMatrixEncoding matrix_encoding;
1325
    AVDownmixInfo *downmix_info;
1326

Justin Ruggles's avatar
Justin Ruggles committed
1327 1328
    /* copy input buffer to decoder context to avoid reading past the end
       of the buffer, which can be caused by a damaged input stream. */
1329 1330 1331 1332 1333
    if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
        // seems to be byte-swapped AC-3
        int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
        s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
    } else
1334
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1335 1336
    buf = s->input_buffer;
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1337
    init_get_bits(&s->gbc, buf, buf_size * 8);
1338

1339
    /* parse the syncinfo */
1340
    err = parse_frame_header(s);
1341

1342
    if (err) {
1343 1344 1345
        switch (err) {
        case AAC_AC3_PARSE_ERROR_SYNC:
            av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1346
            return AVERROR_INVALIDDATA;
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
        case AAC_AC3_PARSE_ERROR_BSID:
            av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
            break;
        case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
            av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
            break;
        case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
            av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
            break;
        case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
            /* skip frame if CRC is ok. otherwise use error concealment. */
            /* TODO: add support for substreams and dependent frames */
            if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1360
                av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1361 1362
                       "skipping frame\n");
                *got_frame_ptr = 0;
1363
                return buf_size;
1364 1365 1366 1367
            } else {
                av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
            }
            break;
1368 1369
        case AAC_AC3_PARSE_ERROR_CRC:
        case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1370
            break;
1371 1372 1373
        default: // Normal AVERROR do not try to recover.
            *got_frame_ptr = 0;
            return err;
1374
        }
1375 1376 1377 1378 1379
    } else {
        /* check that reported frame size fits in input buffer */
        if (s->frame_size > buf_size) {
            av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
            err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1380
        } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1381
            /* check for crc mismatch */
1382 1383
            if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
                       s->frame_size - 2)) {
1384
                av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1385 1386
                if (avctx->err_recognition & AV_EF_EXPLODE)
                    return AVERROR_INVALIDDATA;
1387 1388 1389
                err = AAC_AC3_PARSE_ERROR_CRC;
            }
        }
1390
    }
1391

1392 1393
    /* if frame is ok, set audio parameters */
    if (!err) {
Justin Ruggles's avatar
Justin Ruggles committed
1394
        avctx->sample_rate = s->sample_rate;
1395
        avctx->bit_rate    = s->bit_rate;
1396
    }
Justin Ruggles's avatar
Justin Ruggles committed
1397

1398 1399
    /* channel config */
    if (!err || (s->channels && s->out_channels != s->channels)) {
Justin Ruggles's avatar
Justin Ruggles committed
1400
        s->out_channels = s->channels;
1401 1402
        s->output_mode  = s->channel_mode;
        if (s->lfe_on)
1403
            s->output_mode |= AC3_OUTPUT_LFEON;
1404 1405 1406 1407 1408 1409 1410 1411
        if (s->channels > 1 &&
            avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
            s->out_channels = 1;
            s->output_mode  = AC3_CHMODE_MONO;
        } else if (s->channels > 2 &&
                   avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
            s->out_channels = 2;
            s->output_mode  = AC3_CHMODE_STEREO;
Justin Ruggles's avatar
Justin Ruggles committed
1412
        }
1413

1414 1415
        s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
        s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1416 1417
        s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
        s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
Justin Ruggles's avatar
Justin Ruggles committed
1418
        /* set downmixing coefficients if needed */
1419
        if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
Justin Ruggles's avatar
Justin Ruggles committed
1420 1421 1422
                s->fbw_channels == s->out_channels)) {
            set_downmix_coeffs(s);
        }
1423 1424
    } else if (!s->channels) {
        av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1425 1426
        return AVERROR_INVALIDDATA;
    }
1427
    avctx->channels = s->out_channels;
1428 1429 1430
    avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
    if (s->output_mode & AC3_OUTPUT_LFEON)
        avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1431

1432 1433 1434 1435
    /* set audio service type based on bitstream mode for AC-3 */
    avctx->audio_service_type = s->bitstream_mode;
    if (s->bitstream_mode == 0x7 && s->channels > 1)
        avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1436

1437
    /* get output buffer */
1438
    frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1439
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1440 1441
        return ret;

1442
    /* decode the audio blocks */
1443
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1444 1445
    for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
        output[ch] = s->output[ch];
1446
        s->outptr[ch] = s->output[ch];
1447
    }
1448 1449
    for (ch = 0; ch < s->channels; ch++) {
        if (ch < s->out_channels)
1450
            s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1451
    }
1452
    for (blk = 0; blk < s->num_blocks; blk++) {
1453 1454
        if (!err && decode_audio_block(s, blk)) {
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1455
            err = 1;
1456
        }
1457 1458
        if (err)
            for (ch = 0; ch < s->out_channels; ch++)
1459
                memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1460
        for (ch = 0; ch < s->out_channels; ch++)
1461
            output[ch] = s->outptr[channel_map[ch]];
1462
        for (ch = 0; ch < s->out_channels; ch++) {
1463 1464
            if (!ch || channel_map[ch])
                s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1465
        }
1466
    }
1467

1468
    av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1469

1470 1471
    /* keep last block for error concealment in next frame */
    for (ch = 0; ch < s->out_channels; ch++)
1472
        memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1473

1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502
    /*
     * AVMatrixEncoding
     *
     * Check whether the input layout is compatible, and make sure we're not
     * downmixing (else the matrix encoding is no longer applicable).
     */
    matrix_encoding = AV_MATRIX_ENCODING_NONE;
    if (s->channel_mode == AC3_CHMODE_STEREO &&
        s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
        if (s->dolby_surround_mode == AC3_DSURMOD_ON)
            matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
        else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
            matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
    } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
               s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
        switch (s->dolby_surround_ex_mode) {
        case AC3_DSUREXMOD_ON: // EX or PLIIx
            matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
            break;
        case AC3_DSUREXMOD_PLIIZ:
            matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
            break;
        default: // not indicated or off
            break;
        }
    }
    if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
        return ret;

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
    /* AVDownmixInfo */
    if ((downmix_info = av_downmix_info_update_side_data(frame))) {
        switch (s->preferred_downmix) {
        case AC3_DMIXMOD_LTRT:
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
            break;
        case AC3_DMIXMOD_LORO:
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
            break;
        case AC3_DMIXMOD_DPLII:
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
            break;
        default:
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
            break;
        }
        downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
        downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
        downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
        downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
        if (s->lfe_mix_level_exists)
            downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
        else
            downmix_info->lfe_mix_level       = 0.0; // -inf dB
    } else
        return AVERROR(ENOMEM);

1530
    *got_frame_ptr = 1;
1531

1532
    return FFMIN(buf_size, s->frame_size);
1533
}
1534

1535 1536
/**
 * Uninitialize the AC-3 decoder.
1537
 */
1538
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1539
{
1540
    AC3DecodeContext *s = avctx->priv_data;
1541 1542
    ff_mdct_end(&s->imdct_512);
    ff_mdct_end(&s->imdct_256);
1543

1544 1545 1546
    return 0;
}

1547 1548 1549
#define OFFSET(x) offsetof(AC3DecodeContext, x)
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
static const AVOption options[] = {
1550
    { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1551

1552
{"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1553 1554 1555 1556
{"ltrt_cmixlev",   "Lt/Rt Center Mix Level",   OFFSET(ltrt_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
{"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
{"loro_cmixlev",   "Lo/Ro Center Mix Level",   OFFSET(loro_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
{"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1557

1558 1559 1560 1561
    { NULL},
};

static const AVClass ac3_decoder_class = {
1562
    .class_name = "AC3 decoder",
1563 1564 1565 1566 1567
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

1568
AVCodec ff_ac3_decoder = {
1569
    .name           = "ac3",
1570
    .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1571
    .type           = AVMEDIA_TYPE_AUDIO,
1572
    .id             = AV_CODEC_ID_AC3,
1573
    .priv_data_size = sizeof (AC3DecodeContext),
1574 1575 1576 1577
    .init           = ac3_decode_init,
    .close          = ac3_decode_end,
    .decode         = ac3_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
1578
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1579 1580
                                                      AV_SAMPLE_FMT_NONE },
    .priv_class     = &ac3_decoder_class,
1581 1582
};

1583
#if CONFIG_EAC3_DECODER
1584 1585 1586 1587 1588 1589
static const AVClass eac3_decoder_class = {
    .class_name = "E-AC3 decoder",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};
1590

1591
AVCodec ff_eac3_decoder = {
1592
    .name           = "eac3",
1593
    .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1594
    .type           = AVMEDIA_TYPE_AUDIO,
1595
    .id             = AV_CODEC_ID_EAC3,
1596
    .priv_data_size = sizeof (AC3DecodeContext),
1597 1598 1599 1600
    .init           = ac3_decode_init,
    .close          = ac3_decode_end,
    .decode         = ac3_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
1601
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1602 1603
                                                      AV_SAMPLE_FMT_NONE },
    .priv_class     = &eac3_decoder_class,
1604
};
1605
#endif