ac3dec.c 66.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 "bswapdsp.h"
37
#include "internal.h"
38
#include "aac_ac3_parser.h"
39
#include "ac3_parser_internal.h"
40
#include "ac3dec.h"
41
#include "ac3dec_data.h"
42
#include "kbdwin.h"
43

44 45 46 47 48
/**
 * 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];
49

50
/** tables for ungrouping mantissas */
51 52 53 54 55
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];
56

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

66
#if (!USE_FIXED)
67
/** dynamic range table. converts codes to scale factors. */
68
static float dynamic_range_tab[256];
69 70
float ff_ac3_heavy_dynamic_range_tab[256];
#endif
71

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

85 86 87 88 89 90 91 92 93
/** 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
};

94 95 96 97 98
/**
 * 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] = {
99 100 101 102 103 104 105 106
    { { 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 }, },
107
};
108

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

120 121 122
/*
 * Initialize tables at runtime.
 */
123
static av_cold void ac3_tables_init(void)
124
{
125
    int i;
126

127 128
    /* generate table for ungrouping 3 values in 7 bits
       reference: Section 7.1.3 Exponent Decoding */
129
    for (i = 0; i < 128; i++) {
130 131 132 133 134
        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;
    }

135 136
    /* generate grouped mantissa tables
       reference: Section 7.3.5 Ungrouping of Mantissas */
137
    for (i = 0; i < 32; i++) {
138
        /* bap=1 mantissas */
139 140 141
        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);
142
    }
143
    for (i = 0; i < 128; i++) {
144
        /* bap=2 mantissas */
145 146 147
        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);
148 149 150 151 152 153 154

        /* 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 */
155
    for (i = 0; i < 7; i++) {
156 157 158
        /* bap=3 mantissas */
        b3_mantissas[i] = symmetric_dequant(i, 7);
    }
159
    for (i = 0; i < 15; i++) {
160 161 162
        /* bap=5 mantissas */
        b5_mantissas[i] = symmetric_dequant(i, 15);
    }
163

164
#if (!USE_FIXED)
165 166
    /* generate dynamic range table
       reference: Section 7.7.1 Dynamic Range Control */
167
    for (i = 0; i < 256; i++) {
168
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
169
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
170
    }
171 172 173 174 175

    /* generate compr dynamic range table
       reference: Section 7.7.2 Heavy Compression */
    for (i = 0; i < 256; i++) {
        int v = (i >> 4) - ((i >> 7) << 4) - 4;
176
        ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
177
    }
178
#endif
179 180
}

181 182 183
/**
 * AVCodec initialization
 */
184
static av_cold int ac3_decode_init(AVCodecContext *avctx)
185
{
186
    AC3DecodeContext *s = avctx->priv_data;
187 188
    int i;

189
    s->avctx = avctx;
190

191
    ac3_tables_init();
192 193
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
194
    AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
195
    ff_bswapdsp_init(&s->bdsp);
196

197
#if (USE_FIXED)
198
    s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
199
#else
200
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
201
    ff_fmt_convert_init(&s->fmt_conv, avctx);
202 203
#endif

204
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
205
    av_lfg_init(&s->dith_state, 0);
206

207
    if (USE_FIXED)
208 209 210
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
    else
        avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
211

212
    /* allow downmixing to stereo or mono */
213 214 215 216 217 218
    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;
219
    s->downmixed = 1;
220

221 222 223 224 225
    for (i = 0; i < AC3_MAX_CHANNELS; i++) {
        s->xcfptr[i] = s->transform_coeffs[i];
        s->dlyptr[i] = s->delay[i];
    }

226
    return 0;
227 228
}

229
/**
230
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
231
 * GetBitContext within AC3DecodeContext must point to
232
 * the start of the synchronized AC-3 bitstream.
233
 */
234
static int ac3_parse_header(AC3DecodeContext *s)
235 236 237 238 239
{
    GetBitContext *gbc = &s->gbc;
    int i;

    /* read the rest of the bsi. read twice for dual mono mode. */
240
    i = !s->channel_mode;
241
    do {
242 243 244 245 246 247 248 249 250 251 252 253 254
        s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
        if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
            s->dialog_normalization[(!s->channel_mode)-i] = -31;
        }
        if (s->target_level != 0) {
            s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
                (float)(s->target_level -
                s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
        }
        if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
            s->heavy_dynamic_range[(!s->channel_mode)-i] =
                AC3_HEAVY_RANGE(get_bits(gbc, 8));
        }
255 256 257 258 259 260 261 262
        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

263
    /* skip the timecodes or parse the Alternate Bit Stream Syntax */
264 265 266 267 268 269
    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 {
270 271 272
        if (get_bits1(gbc)) {
            s->preferred_downmix       = get_bits(gbc, 2);
            s->center_mix_level_ltrt   = get_bits(gbc, 3);
273
            s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
274
            s->center_mix_level        = get_bits(gbc, 3);
275
            s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
276
        }
277 278 279 280 281 282
        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)
        }
    }
283 284 285 286 287 288

    /* skip additional bitstream info */
    if (get_bits1(gbc)) {
        i = get_bits(gbc, 6);
        do {
            skip_bits(gbc, 8);
289
        } while (i--);
290 291 292 293 294 295
    }

    return 0;
}

/**
296
 * Common function to parse AC-3 or E-AC-3 frame header
297 298
 */
static int parse_frame_header(AC3DecodeContext *s)
299
{
300
    AC3HeaderInfo hdr;
301
    int err;
302

303
    err = ff_ac3_parse_header(&s->gbc, &hdr);
304
    if (err)
305 306 307
        return err;

    /* get decoding parameters from header info */
308
    s->bit_alloc_params.sr_code     = hdr.sr_code;
309
    s->bitstream_id                 = hdr.bitstream_id;
310
    s->bitstream_mode               = hdr.bitstream_mode;
311
    s->channel_mode                 = hdr.channel_mode;
312
    s->lfe_on                       = hdr.lfe_on;
313
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
314
    s->sample_rate                  = hdr.sample_rate;
315 316 317 318 319
    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;
320
    s->superframe_size             += hdr.frame_size;
321
    s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
322
    s->center_mix_level             = hdr.center_mix_level;
323
    s->center_mix_level_ltrt        = 4; // -3.0dB
324
    s->surround_mix_level           = hdr.surround_mix_level;
325 326
    s->surround_mix_level_ltrt      = 4; // -3.0dB
    s->lfe_mix_level_exists         = 0;
327
    s->num_blocks                   = hdr.num_blocks;
328
    s->frame_type                   = hdr.frame_type;
329
    s->substreamid                  = hdr.substreamid;
330
    s->dolby_surround_mode          = hdr.dolby_surround_mode;
331 332
    s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
    s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
333

334 335 336
    if (s->lfe_on) {
        s->start_freq[s->lfe_ch]     = 0;
        s->end_freq[s->lfe_ch]       = 7;
337 338 339 340
        s->num_exp_groups[s->lfe_ch] = 2;
        s->channel_in_cpl[s->lfe_ch] = 0;
    }

341
    if (s->bitstream_id <= 10) {
342 343 344 345 346 347 348 349 350 351
        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
352
        return ac3_parse_header(s);
353
    } else if (CONFIG_EAC3_DECODER) {
354 355
        s->eac3 = 1;
        return ff_eac3_parse_header(s);
356 357
    } else {
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
358
        return AVERROR(ENOSYS);
359
    }
360 361 362 363 364 365
}

/**
 * Set stereo downmixing coefficients based on frame header info.
 * reference: Section 7.8.2 Downmixing Into Two Channels
 */
366
static int set_downmix_coeffs(AC3DecodeContext *s)
367 368
{
    int i;
369 370
    float cmix = gain_levels[s->  center_mix_level];
    float smix = gain_levels[s->surround_mix_level];
Loren Merritt's avatar
Loren Merritt committed
371
    float norm0, norm1;
372
    float downmix_coeffs[2][AC3_MAX_CHANNELS];
373

374
    if (!s->downmix_coeffs[0]) {
375 376
        s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
                                               sizeof(**s->downmix_coeffs));
377 378 379 380
        if (!s->downmix_coeffs[0])
            return AVERROR(ENOMEM);
        s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
    }
381

382
    for (i = 0; i < s->fbw_channels; i++) {
383 384
        downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
        downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
385
    }
386
    if (s->channel_mode > 1 && s->channel_mode & 1) {
387
        downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
388
    }
389
    if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
390
        int nf = s->channel_mode - 2;
391
        downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
392
    }
393
    if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
394
        int nf = s->channel_mode - 4;
395
        downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
396
    }
397

Loren Merritt's avatar
Loren Merritt committed
398 399
    /* renormalize */
    norm0 = norm1 = 0.0;
400
    for (i = 0; i < s->fbw_channels; i++) {
401 402
        norm0 += downmix_coeffs[0][i];
        norm1 += downmix_coeffs[1][i];
Loren Merritt's avatar
Loren Merritt committed
403 404 405
    }
    norm0 = 1.0f / norm0;
    norm1 = 1.0f / norm1;
406
    for (i = 0; i < s->fbw_channels; i++) {
407 408
        downmix_coeffs[0][i] *= norm0;
        downmix_coeffs[1][i] *= norm1;
Loren Merritt's avatar
Loren Merritt committed
409 410
    }

411 412
    if (s->output_mode == AC3_CHMODE_MONO) {
        for (i = 0; i < s->fbw_channels; i++)
413 414
            downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
                                    downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
415 416
    }
    for (i = 0; i < s->fbw_channels; i++) {
417 418
        s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
        s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
419
    }
420 421

    return 0;
422 423
}

424
/**
425 426
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
427
 */
428 429
static int decode_exponents(AC3DecodeContext *s,
                            GetBitContext *gbc, int exp_strategy, int ngrps,
430
                            uint8_t absexp, int8_t *dexps)
431
{
432
    int i, j, grp, group_size;
433 434 435 436
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
437
    group_size = exp_strategy + (exp_strategy == EXP_D45);
438
    for (grp = 0, i = 0; grp < ngrps; grp++) {
439
        expacc = get_bits(gbc, 7);
440 441 442 443
        if (expacc >= 125) {
            av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
            return AVERROR_INVALIDDATA;
        }
444 445 446
        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];
447
    }
448

449 450
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
451
    for (i = 0, j = 0; i < ngrps * 3; i++) {
452
        prevexp += dexp[i] - 2;
453 454
        if (prevexp > 24U) {
            av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
455
            return -1;
456
        }
457
        switch (group_size) {
458 459 460 461
        case 4: dexps[j++] = prevexp;
                dexps[j++] = prevexp;
        case 2: dexps[j++] = prevexp;
        case 1: dexps[j++] = prevexp;
462
        }
463
    }
464
    return 0;
465 466
}

467
/**
468
 * Generate transform coefficients for each coupled channel in the coupling
469 470 471
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
472
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
473
{
474
    int bin, band, ch;
475 476 477

    bin = s->start_freq[CPL_CH];
    for (band = 0; band < s->num_cpl_bands; band++) {
478
        int band_start = bin;
479
        int band_end = bin + s->cpl_band_sizes[band];
480 481
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (s->channel_in_cpl[ch]) {
482
                int cpl_coord = s->cpl_coords[ch][band] << 5;
483
                for (bin = band_start; bin < band_end; bin++) {
484
                    s->fixed_coeffs[ch][bin] =
485
                        MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
486 487 488 489
                }
                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];
490
                }
491
            }
492
        }
493
        bin = band_end;
494 495 496
    }
}

497 498 499
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
500
typedef struct mant_groups {
501 502 503 504 505 506
    int b1_mant[2];
    int b2_mant[2];
    int b4_mant;
    int b1;
    int b2;
    int b4;
507 508
} mant_groups;

509
/**
510
 * Decode the transform coefficients for a particular channel
511 512
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
513
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
514
{
515
    int start_freq = s->start_freq[ch_index];
516 517 518
    int end_freq   = s->end_freq[ch_index];
    uint8_t *baps  = s->bap[ch_index];
    int8_t *exps   = s->dexps[ch_index];
519
    int32_t *coeffs = s->fixed_coeffs[ch_index];
520
    int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
521
    GetBitContext *gbc = &s->gbc;
522
    int freq;
523

524
    for (freq = start_freq; freq < end_freq; freq++) {
525 526
        int bap = baps[freq];
        int mantissa;
527 528
        switch (bap) {
        case 0:
529
            /* random noise with approximate range of -0.707 to 0.707 */
530
            if (dither)
531
                mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
            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. */
578 579 580 581
            if (bap > 15) {
                av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
                bap = 15;
            }
582
            mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
583
            break;
584
        }
585
        coeffs[freq] = mantissa >> exps[freq];
586 587 588
    }
}

589
/**
590 591
 * Remove random dithering from coupling range coefficients with zero-bit
 * mantissas for coupled channels which do not use dithering.
592 593
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
594
static void remove_dithering(AC3DecodeContext *s) {
595 596
    int ch, i;

597 598 599 600
    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])
601
                    s->fixed_coeffs[ch][i] = 0;
602 603 604 605 606
            }
        }
    }
}

607 608
static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
                                              int ch, mant_groups *m)
609 610
{
    if (!s->channel_uses_aht[ch]) {
611
        ac3_decode_transform_coeffs_ch(s, ch, m);
612 613 614 615
    } else {
        /* if AHT is used, mantissas for all blocks are encoded in the first
           block of the frame. */
        int bin;
616
        if (CONFIG_EAC3_DECODER && !blk)
617
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
618
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
619
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
620 621 622 623
        }
    }
}

624
/**
625
 * Decode the transform coefficients.
626
 */
627
static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
628
{
629
    int ch, end;
630
    int got_cplchan = 0;
631 632
    mant_groups m;

633
    m.b1 = m.b2 = m.b4 = 0;
634

635
    for (ch = 1; ch <= s->channels; ch++) {
636
        /* transform coefficients for full-bandwidth channel */
637
        decode_transform_coeffs_ch(s, blk, ch, &m);
Diego Biurrun's avatar
Diego Biurrun committed
638
        /* transform coefficients for coupling channel come right after the
639
           coefficients for the first coupled channel*/
640
        if (s->channel_in_cpl[ch])  {
641
            if (!got_cplchan) {
642
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
643
                calc_transform_coeffs_cpl(s);
644 645
                got_cplchan = 1;
            }
646
            end = s->end_freq[CPL_CH];
647
        } else {
648
            end = s->end_freq[ch];
649
        }
650
        do
651
            s->fixed_coeffs[ch][end] = 0;
652
        while (++end < 256);
653
    }
654

655
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
656
    remove_dithering(s);
657 658
}

659
/**
660
 * Stereo rematrixing.
661 662
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
663
static void do_rematrixing(AC3DecodeContext *s)
664
{
665
    int bnd, i;
666 667
    int end, bndend;

668
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
669

670 671 672 673
    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++) {
674
                int tmp0 = s->fixed_coeffs[1][i];
675
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
676
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
677 678
            }
        }
679 680
    }
}
681

682 683 684 685 686
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
687
static inline void do_imdct(AC3DecodeContext *s, int channels, int offset)
688
{
Justin Ruggles's avatar
Justin Ruggles committed
689
    int ch;
690

691
    for (ch = 1; ch <= channels; ch++) {
692
        if (s->block_switch[ch]) {
Loren Merritt's avatar
Loren Merritt committed
693
            int i;
694
            FFTSample *x = s->tmp_output + 128;
695 696
            for (i = 0; i < 128; i++)
                x[i] = s->transform_coeffs[ch][2 * i];
697
            s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
698
#if USE_FIXED
699
            s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
700 701
                                       s->tmp_output, s->window, 128, 8);
#else
702
            s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
703
                                       s->tmp_output, s->window, 128);
704
#endif
705 706
            for (i = 0; i < 128; i++)
                x[i] = s->transform_coeffs[ch][2 * i + 1];
707
            s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
708
        } else {
709
            s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
710
#if USE_FIXED
711
            s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
712 713
                                       s->tmp_output, s->window, 128, 8);
#else
714
            s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
715
                                       s->tmp_output, s->window, 128);
716
#endif
717
            memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample));
718
        }
719 720 721
    }
}

722 723 724 725 726
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
727
    int channel_data_size = sizeof(s->delay[0]);
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
    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;
747 748 749
    }
}

750 751
/**
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
752 753 754 755
 * 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.
 *
756 757 758 759 760 761 762 763 764
 * @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)
765
 * @param[in,out] band_struct current band structure
766 767 768 769
 */
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,
770 771
                                  int *num_bands, uint8_t *band_sizes,
                                  uint8_t *band_struct, int band_struct_size)
772
{
773
    int subbnd, bnd, n_subbands, n_bands=0;
774
    uint8_t bnd_sz[22];
775 776 777

    n_subbands = end_subband - start_subband;

778 779 780 781 782 783 784
    if (!blk)
        memcpy(band_struct, default_band_struct, band_struct_size);

    av_assert0(band_struct_size >= start_subband + n_subbands);

    band_struct += start_subband + 1;

785 786 787
    /* decode band structure from bitstream or use default */
    if (!eac3 || get_bits1(gbc)) {
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
788
            band_struct[subbnd] = get_bits1(gbc);
789 790 791 792 793 794 795
        }
    }

    /* 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 ) {
796
        n_bands = n_subbands;
797 798 799
        bnd_sz[0] = ecpl ? 6 : 12;
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
800
            if (band_struct[subbnd - 1]) {
801 802 803 804 805 806 807 808 809 810 811 812
                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)
813
        memcpy(band_sizes, bnd_sz, n_bands);
814 815
}

816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
static inline int spx_strategy(AC3DecodeContext *s, int blk)
{
    GetBitContext *bc = &s->gbc;
    int fbw_channels = s->fbw_channels;
    int dst_start_freq, dst_end_freq, src_start_freq,
        start_subband, end_subband, ch;

    /* 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(bc);
    }

    /* get the frequency bins of the spx copy region and the spx start
       and end subbands */
    dst_start_freq = get_bits(bc, 2);
    start_subband  = get_bits(bc, 3) + 2;
    if (start_subband > 7)
        start_subband += start_subband - 7;
    end_subband    = get_bits(bc, 3) + 5;
838 839 840
#if USE_FIXED
    s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
#endif
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
    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);
        return AVERROR_INVALIDDATA;
    }
    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);
        return AVERROR_INVALIDDATA;
    }

    s->spx_dst_start_freq = dst_start_freq;
    s->spx_src_start_freq = src_start_freq;
861 862
    if (!USE_FIXED)
        s->spx_dst_end_freq   = dst_end_freq;
863 864 865 866 867

    decode_band_structure(bc, blk, s->eac3, 0,
                          start_subband, end_subband,
                          ff_eac3_default_spx_band_struct,
                          &s->num_spx_bands,
868 869
                          s->spx_band_sizes,
                          s->spx_band_struct, sizeof(s->spx_band_struct));
870 871 872 873 874 875 876 877 878 879 880 881
    return 0;
}

static inline void spx_coordinates(AC3DecodeContext *s)
{
    GetBitContext *bc = &s->gbc;
    int fbw_channels = s->fbw_channels;
    int ch, bnd;

    for (ch = 1; ch <= fbw_channels; ch++) {
        if (s->channel_uses_spx[ch]) {
            if (s->first_spx_coords[ch] || get_bits1(bc)) {
882
                INTFLOAT spx_blend;
883 884 885
                int bin, master_spx_coord;

                s->first_spx_coords[ch] = 0;
886
                spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
887 888 889 890
                master_spx_coord = get_bits(bc, 2) * 3;

                bin = s->spx_src_start_freq;
                for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
891
                    int bandsize = s->spx_band_sizes[bnd];
892
                    int spx_coord_exp, spx_coord_mant;
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
                    INTFLOAT nratio, sblend, nblend;
#if USE_FIXED
                    /* calculate blending factors */
                    int64_t accu = ((bin << 23) + (bandsize << 22))
                                 * (int64_t)s->spx_dst_end_freq;
                    nratio = (int)(accu >> 32);
                    nratio -= spx_blend << 18;

                    if (nratio < 0) {
                        nblend = 0;
                        sblend = 0x800000;
                    } else if (nratio > 0x7fffff) {
                        nblend = 14529495; // sqrt(3) in FP.23
                        sblend = 0;
                    } else {
                        nblend = fixed_sqrt(nratio, 23);
                        accu = (int64_t)nblend * 1859775393;
                        nblend = (int)((accu + (1<<29)) >> 30);
                        sblend = fixed_sqrt(0x800000 - nratio, 23);
                    }
#else
                    float spx_coord;
915 916 917 918 919 920 921

                    /* calculate blending factors */
                    nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
                    nratio = av_clipf(nratio, 0.0f, 1.0f);
                    nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
                                                   // to give unity variance
                    sblend = sqrtf(1.0f - nratio);
922
#endif
923 924 925 926 927 928 929 930 931 932
                    bin += bandsize;

                    /* decode spx coordinates */
                    spx_coord_exp  = get_bits(bc, 4);
                    spx_coord_mant = get_bits(bc, 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);

                    /* multiply noise and signal blending factors by spx coordinate */
933 934 935 936 937 938 939
#if USE_FIXED
                    accu = (int64_t)nblend * spx_coord_mant;
                    s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
                    accu = (int64_t)sblend * spx_coord_mant;
                    s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
#else
                    spx_coord = spx_coord_mant * (1.0f / (1 << 23));
940 941
                    s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
                    s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
942
#endif
943 944 945 946 947 948 949 950
                }
            }
        } else {
            s->first_spx_coords[ch] = 1;
        }
    }
}

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
static inline int coupling_strategy(AC3DecodeContext *s, int blk,
                                    uint8_t *bit_alloc_stages)
{
    GetBitContext *bc = &s->gbc;
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
    int ch;

    memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
    if (!s->eac3)
        s->cpl_in_use[blk] = get_bits1(bc);
    if (s->cpl_in_use[blk]) {
        /* coupling in use */
        int cpl_start_subband, cpl_end_subband;

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

        /* check for enhanced coupling */
        if (s->eac3 && get_bits1(bc)) {
            /* TODO: parse enhanced coupling strategy info */
            avpriv_request_sample(s->avctx, "Enhanced coupling");
            return AVERROR_PATCHWELCOME;
        }

        /* determine which channels are coupled */
        if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
            s->channel_in_cpl[1] = 1;
            s->channel_in_cpl[2] = 1;
        } else {
            for (ch = 1; ch <= fbw_channels; ch++)
                s->channel_in_cpl[ch] = get_bits1(bc);
        }

        /* phase flags in use */
        if (channel_mode == AC3_CHMODE_STEREO)
            s->phase_flags_in_use = get_bits1(bc);

        /* coupling frequency range */
        cpl_start_subband = get_bits(bc, 4);
        cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
                                          get_bits(bc, 4) + 3;
        if (cpl_start_subband >= cpl_end_subband) {
            av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
                   cpl_start_subband, cpl_end_subband);
            return AVERROR_INVALIDDATA;
        }
        s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
        s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;

        decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
                              cpl_end_subband,
                              ff_eac3_default_cpl_band_struct,
1006 1007
                              &s->num_cpl_bands, s->cpl_band_sizes,
                              s->cpl_band_struct, sizeof(s->cpl_band_struct));
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
    } else {
        /* coupling not in use */
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->channel_in_cpl[ch] = 0;
            s->first_cpl_coords[ch] = 1;
        }
        s->first_cpl_leak = s->eac3;
        s->phase_flags_in_use = 0;
    }

    return 0;
}

static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
{
    GetBitContext *bc = &s->gbc;
    int fbw_channels = s->fbw_channels;
    int ch, bnd;
    int cpl_coords_exist = 0;

    for (ch = 1; ch <= fbw_channels; ch++) {
        if (s->channel_in_cpl[ch]) {
            if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
                int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
                s->first_cpl_coords[ch] = 0;
                cpl_coords_exist = 1;
                master_cpl_coord = 3 * get_bits(bc, 2);
                for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
                    cpl_coord_exp  = get_bits(bc, 4);
                    cpl_coord_mant = get_bits(bc, 4);
                    if (cpl_coord_exp == 15)
                        s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
                    else
                        s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
                    s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
                }
            } else if (!blk) {
                av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
                       "be present in block 0\n");
                return AVERROR_INVALIDDATA;
            }
        } else {
            /* channel not in coupling */
            s->first_cpl_coords[ch] = 1;
        }
    }
    /* phase flags */
    if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
        for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
            s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
        }
    }

    return 0;
}

1064
/**
1065
 * Decode a single audio block from the AC-3 bitstream.
1066
 */
1067
static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1068
{
1069 1070
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
1071
    int i, bnd, seg, ch, ret;
1072 1073
    int different_transforms;
    int downmix_output;
1074
    int cpl_in_use;
1075
    GetBitContext *gbc = &s->gbc;
1076
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1077

1078
    /* block switch flags */
1079
    different_transforms = 0;
1080
    if (s->block_switch_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
1081 1082
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->block_switch[ch] = get_bits1(gbc);
1083
            if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
Justin Ruggles's avatar
Justin Ruggles committed
1084 1085
                different_transforms = 1;
        }
1086
    }
1087

1088
    /* dithering flags */
1089
    if (s->dither_flag_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
1090 1091 1092
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->dither_flag[ch] = get_bits1(gbc);
        }
1093
    }
1094

1095
    /* dynamic range */
1096
    i = !s->channel_mode;
1097
    do {
1098
        if (get_bits1(gbc)) {
1099 1100
            /* Allow asymmetric application of DRC when drc_scale > 1.
               Amplification of quiet sounds is enhanced */
1101 1102 1103
            int range_bits = get_bits(gbc, 8);
            INTFLOAT range = AC3_RANGE(range_bits);
            if (range_bits <= 127 || s->drc_scale <= 1.0)
1104
                s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1105 1106
            else
                s->dynamic_range[i] = range;
1107
        } else if (blk == 0) {
1108
            s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1109
        }
1110
    } while (i--);
1111

1112 1113
    /* spectral extension strategy */
    if (s->eac3 && (!blk || get_bits1(gbc))) {
1114 1115
        s->spx_in_use = get_bits1(gbc);
        if (s->spx_in_use) {
1116 1117
            if ((ret = spx_strategy(s, blk)) < 0)
                return ret;
1118 1119 1120 1121 1122 1123 1124
        }
    }
    if (!s->eac3 || !s->spx_in_use) {
        s->spx_in_use = 0;
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->channel_uses_spx[ch] = 0;
            s->first_spx_coords[ch] = 1;
1125 1126 1127
        }
    }

1128
    /* spectral extension coordinates */
1129 1130
    if (s->spx_in_use)
        spx_coordinates(s);
1131

1132
    /* coupling strategy */
1133
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1134 1135
        if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
            return ret;
1136
    } else if (!s->eac3) {
1137 1138 1139
        if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
                   "be present in block 0\n");
1140
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1141 1142 1143
        } else {
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
        }
1144
    }
1145
    cpl_in_use = s->cpl_in_use[blk];
1146

1147
    /* coupling coordinates */
1148
    if (cpl_in_use) {
1149 1150
        if ((ret = coupling_coordinates(s, blk)) < 0)
            return ret;
1151
    }
1152

1153
    /* stereo rematrixing strategy and band structure */
1154
    if (channel_mode == AC3_CHMODE_STEREO) {
1155
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1156
            s->num_rematrixing_bands = 4;
1157
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1158
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1159 1160 1161
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
                s->num_rematrixing_bands--;
            }
1162
            for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1163
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1164
        } else if (!blk) {
1165 1166
            av_log(s->avctx, AV_LOG_WARNING, "Warning: "
                   "new rematrixing strategy not present in block 0\n");
1167
            s->num_rematrixing_bands = 0;
1168
        }
1169 1170
    }

1171
    /* exponent strategies for each channel */
1172
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1173
        if (!s->eac3)
1174
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1175
        if (s->exp_strategy[blk][ch] != EXP_REUSE)
1176 1177 1178
            bit_alloc_stages[ch] = 3;
    }

1179
    /* channel bandwidth */
1180
    for (ch = 1; ch <= fbw_channels; ch++) {
1181
        s->start_freq[ch] = 0;
1182
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1183
            int group_size;
1184 1185 1186
            int prev = s->end_freq[ch];
            if (s->channel_in_cpl[ch])
                s->end_freq[ch] = s->start_freq[CPL_CH];
1187 1188
            else if (s->channel_uses_spx[ch])
                s->end_freq[ch] = s->spx_src_start_freq;
1189
            else {
1190
                int bandwidth_code = get_bits(gbc, 6);
1191
                if (bandwidth_code > 60) {
1192
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1193
                    return AVERROR_INVALIDDATA;
1194
                }
1195
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1196
            }
1197
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1198 1199
            s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
            if (blk > 0 && s->end_freq[ch] != prev)
1200
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1201
        }
1202
    }
1203
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1204
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1205
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1206
    }
1207

1208
    /* decode exponents for each channel */
1209
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1210
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1211
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1212
            if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1213 1214
                                 s->num_exp_groups[ch], s->dexps[ch][0],
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1215
                return AVERROR_INVALIDDATA;
1216
            }
1217
            if (ch != CPL_CH && ch != s->lfe_ch)
1218
                skip_bits(gbc, 2); /* skip gainrng */
1219
        }
1220
    }
1221

1222
    /* bit allocation information */
1223
    if (s->bit_allocation_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
1224 1225 1226 1227 1228
        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)];
1229
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1230
            for (ch = !cpl_in_use; ch <= s->channels; ch++)
Justin Ruggles's avatar
Justin Ruggles committed
1231 1232
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
        } else if (!blk) {
1233 1234
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
                   "be present in block 0\n");
1235
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1236
        }
1237
    }
1238

1239
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1240 1241
    if (!s->eac3 || !blk) {
        if (s->snr_offset_strategy && get_bits1(gbc)) {
Justin Ruggles's avatar
Justin Ruggles committed
1242 1243 1244 1245 1246 1247 1248 1249
            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 */
1250
                if (blk && s->snr_offset[ch] != snr) {
Justin Ruggles's avatar
Justin Ruggles committed
1251 1252 1253
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
                }
                s->snr_offset[ch] = snr;
1254 1255 1256 1257

                /* fast gain (normal AC-3 only) */
                if (!s->eac3) {
                    int prev = s->fast_gain[ch];
Justin Ruggles's avatar
Justin Ruggles committed
1258
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1259
                    /* run last 2 bit allocation stages if fast gain changes */
1260
                    if (blk && prev != s->fast_gain[ch])
1261 1262
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
                }
Justin Ruggles's avatar
Justin Ruggles committed
1263
            }
1264
        } else if (!s->eac3 && !blk) {
Justin Ruggles's avatar
Justin Ruggles committed
1265
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1266
            return AVERROR_INVALIDDATA;
1267
        }
1268
    }
1269

1270 1271 1272 1273 1274 1275
    /* 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 */
1276
            if (blk && prev != s->fast_gain[ch])
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
                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
    }

1289
    /* coupling leak information */
1290
    if (cpl_in_use) {
1291 1292 1293 1294 1295
        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 */
1296 1297
            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
1298
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1299 1300 1301 1302
            }
            s->bit_alloc_params.cpl_fast_leak = fl;
            s->bit_alloc_params.cpl_slow_leak = sl;
        } else if (!s->eac3 && !blk) {
1303 1304
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
                   "be present in block 0\n");
1305
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1306
        }
1307
        s->first_cpl_leak = 0;
1308
    }
1309

1310
    /* delta bit allocation information */
1311
    if (s->dba_syntax && get_bits1(gbc)) {
1312
        /* delta bit allocation exists (strategy) */
1313
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1314 1315 1316
            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");
1317
                return AVERROR_INVALIDDATA;
1318
            }
1319
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1320
        }
1321
        /* channel delta offset, len and bit allocation */
1322
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1323
            if (s->dba_mode[ch] == DBA_NEW) {
1324 1325
                s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
                for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1326 1327
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1328
                    s->dba_values[ch][seg]  = get_bits(gbc, 3);
1329
                }
1330 1331
                /* run last 2 bit allocation stages if new dba values */
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1332
            }
1333
        }
1334 1335
    } else if (blk == 0) {
        for (ch = 0; ch <= s->channels; ch++) {
1336
            s->dba_mode[ch] = DBA_NONE;
1337
        }
1338
    }
1339

1340
    /* Bit allocation */
1341 1342
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
        if (bit_alloc_stages[ch] > 2) {
1343
            /* Exponent mapping into PSD and PSD integration */
1344 1345 1346
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->psd[ch], s->band_psd[ch]);
1347
        }
1348
        if (bit_alloc_stages[ch] > 1) {
1349 1350
            /* Compute excitation function, Compute masking curve, and
               Apply delta bit allocation */
1351
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1352 1353 1354
                                           s->start_freq[ch],  s->end_freq[ch],
                                           s->fast_gain[ch],   (ch == s->lfe_ch),
                                           s->dba_mode[ch],    s->dba_nsegs[ch],
1355
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1356
                                           s->dba_values[ch],  s->mask[ch])) {
1357
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1358
                return AVERROR_INVALIDDATA;
1359
            }
1360
        }
1361
        if (bit_alloc_stages[ch] > 0) {
1362
            /* Compute bit allocation */
1363 1364
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1365
            s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1366 1367 1368
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->snr_offset[ch],
                                      s->bit_alloc_params.floor,
1369
                                      bap_tab, s->bap[ch]);
1370
        }
1371
    }
1372

1373
    /* unused dummy data */
1374
    if (s->skip_syntax && get_bits1(gbc)) {
1375
        int skipl = get_bits(gbc, 9);
1376
        skip_bits_long(gbc, 8 * skipl);
1377
    }
1378

1379
    /* unpack the transform coefficients
1380
       this also uncouples channels if coupling is in use. */
1381
    decode_transform_coeffs(s, blk);
1382

1383 1384
    /* TODO: generate enhanced coupling coordinates and uncouple */

1385
    /* recover coefficients if rematrixing is in use */
1386
    if (s->channel_mode == AC3_CHMODE_STEREO)
1387
        do_rematrixing(s);
1388

1389
    /* apply scaling to coefficients (headroom, dynrng) */
1390
    for (ch = 1; ch <= s->channels; ch++) {
1391
        int audio_channel = 0;
1392
        INTFLOAT gain;
1393
        if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1394 1395 1396 1397 1398 1399
            audio_channel = 2-ch;
        if (s->heavy_compression && s->compression_exists[audio_channel])
            gain = s->heavy_dynamic_range[audio_channel];
        else
            gain = s->dynamic_range[audio_channel];

1400
#if USE_FIXED
1401 1402
        scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
#else
1403 1404
        if (s->target_level != 0)
          gain = gain * s->level_gain[audio_channel];
1405
        gain *= 1.0 / 4194304.0f;
1406 1407
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
                                               s->fixed_coeffs[ch], gain, 256);
1408
#endif
1409
    }
1410

1411
    /* apply spectral extension to high frequency bins */
1412
    if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1413 1414 1415
        ff_eac3_apply_spectral_extension(s);
    }

1416 1417 1418 1419 1420 1421
    /* 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);
1422
    if (different_transforms) {
1423 1424
        /* the delay samples have already been downmixed, so we upmix the delay
           samples in order to reconstruct all channels before downmixing. */
1425
        if (s->downmixed) {
1426 1427 1428 1429
            s->downmixed = 0;
            ac3_upmix_delay(s);
        }

1430
        do_imdct(s, s->channels, offset);
1431

1432
        if (downmix_output) {
1433
#if USE_FIXED
1434 1435 1436
            ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
                              s->out_channels, s->fbw_channels, 256);
#else
1437
            ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
1438
                              s->out_channels, s->fbw_channels, 256);
1439
#endif
1440 1441
        }
    } else {
1442
        if (downmix_output) {
1443
            AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1444
                                          s->out_channels, s->fbw_channels, 256);
1445 1446
        }

1447
        if (downmix_output && !s->downmixed) {
1448
            s->downmixed = 1;
1449
            AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
1450
                                          s->out_channels, s->fbw_channels, 128);
1451
        }
1452

1453
        do_imdct(s, s->out_channels, offset);
1454 1455
    }

1456
    return 0;
1457 1458
}

1459 1460
/**
 * Decode a single AC-3 frame.
1461
 */
1462 1463
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
                            int *got_frame_ptr, AVPacket *avpkt)
1464
{
1465
    AVFrame *frame     = data;
1466
    const uint8_t *buf = avpkt->data;
1467
    int buf_size, full_buf_size = avpkt->size;
1468
    AC3DecodeContext *s = avctx->priv_data;
1469 1470
    int blk, ch, err, offset, ret;
    int got_independent_frame = 0;
1471
    const uint8_t *channel_map;
1472
    uint8_t extended_channel_map[EAC3_MAX_CHANNELS];
1473
    const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1474
    enum AVMatrixEncoding matrix_encoding;
1475
    AVDownmixInfo *downmix_info;
1476

1477 1478 1479
    s->superframe_size = 0;

    buf_size = full_buf_size;
Justin Ruggles's avatar
Justin Ruggles committed
1480 1481
    /* copy input buffer to decoder context to avoid reading past the end
       of the buffer, which can be caused by a damaged input stream. */
1482 1483 1484
    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;
1485 1486
        s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
                            (const uint16_t *) buf, cnt);
1487
    } else
1488
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1489 1490 1491 1492 1493 1494 1495

    /* if consistent noise generation is enabled, seed the linear feedback generator
     * with the contents of the AC-3 frame so that the noise is identical across
     * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
    if (s->consistent_noise_generation)
        av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));

1496
    buf = s->input_buffer;
1497
dependent_frame:
1498
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1499 1500
    if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
        return ret;
1501

1502
    /* parse the syncinfo */
1503
    err = parse_frame_header(s);
1504

1505
    if (err) {
1506 1507 1508
        switch (err) {
        case AAC_AC3_PARSE_ERROR_SYNC:
            av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1509
            return AVERROR_INVALIDDATA;
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
        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. */
1521 1522
            /* TODO: add support for substreams */
            if (s->substreamid) {
1523
                av_log(avctx, AV_LOG_DEBUG,
1524 1525
                       "unsupported substream %d: skipping frame\n",
                       s->substreamid);
1526
                *got_frame_ptr = 0;
1527
                return buf_size;
1528 1529 1530 1531
            } else {
                av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
            }
            break;
1532 1533
        case AAC_AC3_PARSE_ERROR_CRC:
        case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1534
            break;
1535 1536 1537
        default: // Normal AVERROR do not try to recover.
            *got_frame_ptr = 0;
            return err;
1538
        }
1539 1540 1541 1542 1543
    } 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;
1544
        } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1545
            /* check for crc mismatch */
1546 1547
            if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
                       s->frame_size - 2)) {
1548
                av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1549 1550
                if (avctx->err_recognition & AV_EF_EXPLODE)
                    return AVERROR_INVALIDDATA;
1551 1552 1553
                err = AAC_AC3_PARSE_ERROR_CRC;
            }
        }
1554
    }
1555

1556 1557 1558 1559
    if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
        av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
        *got_frame_ptr = 0;
        return FFMIN(full_buf_size, s->frame_size);
1560
    }
Justin Ruggles's avatar
Justin Ruggles committed
1561

1562 1563
    /* channel config */
    if (!err || (s->channels && s->out_channels != s->channels)) {
Justin Ruggles's avatar
Justin Ruggles committed
1564
        s->out_channels = s->channels;
1565 1566
        s->output_mode  = s->channel_mode;
        if (s->lfe_on)
1567
            s->output_mode |= AC3_OUTPUT_LFEON;
1568 1569 1570 1571 1572 1573 1574 1575
        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
1576
        }
1577

1578 1579
        s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
        s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1580 1581
        s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
        s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
Justin Ruggles's avatar
Justin Ruggles committed
1582
        /* set downmixing coefficients if needed */
1583
        if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
Justin Ruggles's avatar
Justin Ruggles committed
1584
                s->fbw_channels == s->out_channels)) {
1585 1586 1587 1588
            if ((ret = set_downmix_coeffs(s)) < 0) {
                av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
                return ret;
            }
Justin Ruggles's avatar
Justin Ruggles committed
1589
        }
1590 1591
    } else if (!s->channels) {
        av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1592 1593
        return AVERROR_INVALIDDATA;
    }
1594
    avctx->channels = s->out_channels;
1595 1596 1597
    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;
1598

1599 1600 1601 1602
    /* 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;
1603

1604
    /* decode the audio blocks */
1605
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1606
    offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1607
    for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1608 1609
        output[ch] = s->output[ch + offset];
        s->outptr[ch] = s->output[ch + offset];
1610
    }
1611 1612
    for (ch = 0; ch < s->channels; ch++) {
        if (ch < s->out_channels)
1613
            s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1614
    }
1615
    for (blk = 0; blk < s->num_blocks; blk++) {
1616
        if (!err && decode_audio_block(s, blk, offset)) {
1617
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1618
            err = 1;
1619
        }
1620 1621
        if (err)
            for (ch = 0; ch < s->out_channels; ch++)
1622
                memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1623
        for (ch = 0; ch < s->out_channels; ch++)
1624
            output[ch] = s->outptr[channel_map[ch]];
1625
        for (ch = 0; ch < s->out_channels; ch++) {
1626 1627
            if (!ch || channel_map[ch])
                s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1628
        }
1629
    }
1630

1631 1632
    /* keep last block for error concealment in next frame */
    for (ch = 0; ch < s->out_channels; ch++)
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
        memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));

    /* check if there is dependent frame */
    if (buf_size > s->frame_size) {
        AC3HeaderInfo hdr;
        int err;

        if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
            return ret;

        err = ff_ac3_parse_header(&s->gbc, &hdr);
        if (err)
            return err;

        if (hdr.frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
            if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) {
                av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n");
            } else {
                buf += s->frame_size;
                buf_size -= s->frame_size;
                s->prev_output_mode = s->output_mode;
                s->prev_bit_rate = s->bit_rate;
                got_independent_frame = 1;
                goto dependent_frame;
            }
        }
    }

    frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;

    /* if frame is ok, set audio parameters */
    if (!err) {
        avctx->sample_rate = s->sample_rate;
        avctx->bit_rate    = s->bit_rate + s->prev_bit_rate;
    }

1669
    for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1670 1671 1672 1673
        extended_channel_map[ch] = ch;

    if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
        uint64_t ich_layout = avpriv_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON];
1674
        int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1675 1676 1677 1678 1679 1680 1681 1682
        uint64_t channel_layout;
        int extend = 0;

        if (s->prev_output_mode & AC3_OUTPUT_LFEON)
            ich_layout |= AV_CH_LOW_FREQUENCY;

        channel_layout = ich_layout;
        for (ch = 0; ch < 16; ch++) {
1683
            if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1684
                channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
1685 1686
            }
        }
1687 1688 1689 1690 1691
        if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
            av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
                   av_get_channel_layout_nb_channels(channel_layout));
            return AVERROR_INVALIDDATA;
        }
1692 1693 1694 1695

        avctx->channel_layout = channel_layout;
        avctx->channels = av_get_channel_layout_nb_channels(channel_layout);

1696 1697
        for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
            if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1698
                if (ff_eac3_custom_channel_map_locations[ch][0]) {
1699
                    int index = av_get_channel_layout_channel_index(channel_layout,
1700
                                                                    ff_eac3_custom_channel_map_locations[ch][1]);
1701 1702
                    if (index < 0)
                        return AVERROR_INVALIDDATA;
1703 1704 1705
                    if (extend >= channel_map_size)
                        return AVERROR_INVALIDDATA;

1706 1707 1708 1709 1710
                    extended_channel_map[index] = offset + channel_map[extend++];
                } else {
                    int i;

                    for (i = 0; i < 64; i++) {
1711
                        if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
1712
                            int index = av_get_channel_layout_channel_index(channel_layout,
1713
                                                                            1ULL << i);
1714 1715
                            if (index < 0)
                                return AVERROR_INVALIDDATA;
1716 1717 1718
                            if (extend >= channel_map_size)
                                return AVERROR_INVALIDDATA;

1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
                            extended_channel_map[index] = offset + channel_map[extend++];
                        }
                    }
                }
            }
        }
    }

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

    for (ch = 0; ch < avctx->channels; ch++) {
        int map = extended_channel_map[ch];
1734 1735 1736
        av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
        memcpy((SHORTFLOAT *)frame->extended_data[ch],
               s->output_buffer[map],
1737 1738
               s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
    }
1739

1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
    /*
     * 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;

1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
    /* 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);

1796
    *got_frame_ptr = 1;
1797

1798 1799 1800
    if (!s->superframe_size)
        return FFMIN(full_buf_size, s->frame_size);

1801
    return FFMIN(full_buf_size, s->superframe_size);
1802
}
1803

1804 1805
/**
 * Uninitialize the AC-3 decoder.
1806
 */
1807
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1808
{
1809
    AC3DecodeContext *s = avctx->priv_data;
1810 1811
    ff_mdct_end(&s->imdct_512);
    ff_mdct_end(&s->imdct_256);
1812
    av_freep(&s->fdsp);
1813
    av_freep(&s->downmix_coeffs[0]);
1814

1815 1816 1817
    return 0;
}

1818 1819
#define OFFSET(x) offsetof(AC3DecodeContext, x)
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)