ac3dec.c 60.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.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
/** dynamic range table. converts codes to scale factors. */
67
static float dynamic_range_tab[256];
68
static float heavy_dynamic_range_tab[256];
69

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

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

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

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

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

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

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

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

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

176 177
}

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

186
    s->avctx = avctx;
187

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

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

201
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
202
    av_lfg_init(&s->dith_state, 0);
203

204
    if (USE_FIXED)
205 206 207
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
    else
        avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
208

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

218 219 220 221 222
    for (i = 0; i < AC3_MAX_CHANNELS; i++) {
        s->xcfptr[i] = s->transform_coeffs[i];
        s->dlyptr[i] = s->delay[i];
    }

223
    return 0;
224 225
}

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

    /* read the rest of the bsi. read twice for dual mono mode. */
237
    i = !s->channel_mode;
238
    do {
239 240 241 242 243 244 245 246 247 248 249 250 251
        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));
        }
252 253 254 255 256 257 258 259
        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

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

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

    return 0;
}

/**
293
 * Common function to parse AC-3 or E-AC-3 frame header
294 295
 */
static int parse_frame_header(AC3DecodeContext *s)
296
{
297
    AC3HeaderInfo hdr, *phdr=&hdr;
298
    int err;
299

300
    err = avpriv_ac3_parse_header(&s->gbc, &phdr);
301
    if (err)
302 303 304
        return err;

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

330 331 332
    if (s->lfe_on) {
        s->start_freq[s->lfe_ch]     = 0;
        s->end_freq[s->lfe_ch]       = 7;
333 334 335 336
        s->num_exp_groups[s->lfe_ch] = 2;
        s->channel_in_cpl[s->lfe_ch] = 0;
    }

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

/**
 * 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;
365 366
    float cmix = gain_levels[s->  center_mix_level];
    float smix = gain_levels[s->surround_mix_level];
Loren Merritt's avatar
Loren Merritt committed
367
    float norm0, norm1;
368
    float downmix_coeffs[AC3_MAX_CHANNELS][2];
369

370
    for (i = 0; i < s->fbw_channels; i++) {
371 372
        downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
        downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
373
    }
374
    if (s->channel_mode > 1 && s->channel_mode & 1) {
375
        downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
376
    }
377
    if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
378
        int nf = s->channel_mode - 2;
379
        downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
380
    }
381
    if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
382
        int nf = s->channel_mode - 4;
383
        downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
384
    }
385

Loren Merritt's avatar
Loren Merritt committed
386 387
    /* renormalize */
    norm0 = norm1 = 0.0;
388
    for (i = 0; i < s->fbw_channels; i++) {
389 390
        norm0 += downmix_coeffs[i][0];
        norm1 += downmix_coeffs[i][1];
Loren Merritt's avatar
Loren Merritt committed
391 392 393
    }
    norm0 = 1.0f / norm0;
    norm1 = 1.0f / norm1;
394
    for (i = 0; i < s->fbw_channels; i++) {
395 396
        downmix_coeffs[i][0] *= norm0;
        downmix_coeffs[i][1] *= norm1;
Loren Merritt's avatar
Loren Merritt committed
397 398
    }

399 400
    if (s->output_mode == AC3_CHMODE_MONO) {
        for (i = 0; i < s->fbw_channels; i++)
401 402 403 404 405 406
            downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
                                    downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
    }
    for (i = 0; i < s->fbw_channels; i++) {
        s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
        s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
407
    }
408 409
}

410
/**
411 412
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
413
 */
414 415
static int decode_exponents(AC3DecodeContext *s,
                            GetBitContext *gbc, int exp_strategy, int ngrps,
416
                            uint8_t absexp, int8_t *dexps)
417
{
418
    int i, j, grp, group_size;
419 420 421 422
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
423
    group_size = exp_strategy + (exp_strategy == EXP_D45);
424
    for (grp = 0, i = 0; grp < ngrps; grp++) {
425
        expacc = get_bits(gbc, 7);
426 427 428
        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];
429
    }
430

431 432
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
433
    for (i = 0, j = 0; i < ngrps * 3; i++) {
434
        prevexp += dexp[i] - 2;
435 436
        if (prevexp > 24U) {
            av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
437
            return -1;
438
        }
439
        switch (group_size) {
440 441 442 443
        case 4: dexps[j++] = prevexp;
                dexps[j++] = prevexp;
        case 2: dexps[j++] = prevexp;
        case 1: dexps[j++] = prevexp;
444
        }
445
    }
446
    return 0;
447 448
}

449
/**
450
 * Generate transform coefficients for each coupled channel in the coupling
451 452 453
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
454
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
455
{
456
    int bin, band, ch;
457 458 459

    bin = s->start_freq[CPL_CH];
    for (band = 0; band < s->num_cpl_bands; band++) {
460
        int band_start = bin;
461
        int band_end = bin + s->cpl_band_sizes[band];
462 463
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (s->channel_in_cpl[ch]) {
464
                int cpl_coord = s->cpl_coords[ch][band] << 5;
465
                for (bin = band_start; bin < band_end; bin++) {
466
                    s->fixed_coeffs[ch][bin] =
467
                        MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
468 469 470 471
                }
                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];
472
                }
473
            }
474
        }
475
        bin = band_end;
476 477 478
    }
}

479 480 481
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
482
typedef struct mant_groups {
483 484 485 486 487 488
    int b1_mant[2];
    int b2_mant[2];
    int b4_mant;
    int b1;
    int b2;
    int b4;
489 490
} mant_groups;

491
/**
492
 * Decode the transform coefficients for a particular channel
493 494
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
495
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
496
{
497
    int start_freq = s->start_freq[ch_index];
498 499 500
    int end_freq   = s->end_freq[ch_index];
    uint8_t *baps  = s->bap[ch_index];
    int8_t *exps   = s->dexps[ch_index];
501
    int32_t *coeffs = s->fixed_coeffs[ch_index];
502
    int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
503
    GetBitContext *gbc = &s->gbc;
504
    int freq;
505

506
    for (freq = start_freq; freq < end_freq; freq++) {
507 508
        int bap = baps[freq];
        int mantissa;
509 510
        switch (bap) {
        case 0:
511
            /* random noise with approximate range of -0.707 to 0.707 */
512
            if (dither)
513
                mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 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
            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. */
560 561 562 563
            if (bap > 15) {
                av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
                bap = 15;
            }
564
            mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
565
            break;
566
        }
567
        coeffs[freq] = mantissa >> exps[freq];
568 569 570
    }
}

571
/**
572 573
 * Remove random dithering from coupling range coefficients with zero-bit
 * mantissas for coupled channels which do not use dithering.
574 575
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
576
static void remove_dithering(AC3DecodeContext *s) {
577 578
    int ch, i;

579 580 581 582
    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])
583
                    s->fixed_coeffs[ch][i] = 0;
584 585 586 587 588
            }
        }
    }
}

589
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
590
                                       mant_groups *m)
591 592
{
    if (!s->channel_uses_aht[ch]) {
593
        ac3_decode_transform_coeffs_ch(s, ch, m);
594 595 596 597
    } else {
        /* if AHT is used, mantissas for all blocks are encoded in the first
           block of the frame. */
        int bin;
598
        if (CONFIG_EAC3_DECODER && !blk)
599
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
600
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
601
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
602 603 604 605
        }
    }
}

606
/**
607
 * Decode the transform coefficients.
608
 */
609
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
610
{
611
    int ch, end;
612
    int got_cplchan = 0;
613 614
    mant_groups m;

615
    m.b1 = m.b2 = m.b4 = 0;
616

617
    for (ch = 1; ch <= s->channels; ch++) {
618
        /* transform coefficients for full-bandwidth channel */
619
        decode_transform_coeffs_ch(s, blk, ch, &m);
Diego Biurrun's avatar
Diego Biurrun committed
620
        /* transform coefficients for coupling channel come right after the
621
           coefficients for the first coupled channel*/
622
        if (s->channel_in_cpl[ch])  {
623
            if (!got_cplchan) {
624
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
625
                calc_transform_coeffs_cpl(s);
626 627
                got_cplchan = 1;
            }
628
            end = s->end_freq[CPL_CH];
629
        } else {
630
            end = s->end_freq[ch];
631
        }
632
        do
633
            s->fixed_coeffs[ch][end] = 0;
634
        while (++end < 256);
635
    }
636

637
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
638
    remove_dithering(s);
639 640
}

641
/**
642
 * Stereo rematrixing.
643 644
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
645
static void do_rematrixing(AC3DecodeContext *s)
646
{
647
    int bnd, i;
648 649
    int end, bndend;

650
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
651

652 653 654 655
    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++) {
656
                int tmp0 = s->fixed_coeffs[1][i];
657
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
658
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
659 660
            }
        }
661 662
    }
}
663

664 665 666 667 668
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
669
static inline void do_imdct(AC3DecodeContext *s, int channels)
670
{
Justin Ruggles's avatar
Justin Ruggles committed
671
    int ch;
672

673
    for (ch = 1; ch <= channels; ch++) {
674
        if (s->block_switch[ch]) {
Loren Merritt's avatar
Loren Merritt committed
675
            int i;
676
            FFTSample *x = s->tmp_output + 128;
677 678
            for (i = 0; i < 128; i++)
                x[i] = s->transform_coeffs[ch][2 * i];
679
            s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
680
#if USE_FIXED
681 682 683
            s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
                                       s->tmp_output, s->window, 128, 8);
#else
684
            s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
685
                                       s->tmp_output, s->window, 128);
686
#endif
687 688 689
            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);
690
        } else {
691
            s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
692
#if USE_FIXED
693 694 695
            s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
                                       s->tmp_output, s->window, 128, 8);
#else
696
            s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
697
                                       s->tmp_output, s->window, 128);
698 699
#endif
            memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
700
        }
701 702 703
    }
}

704 705 706 707 708
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
709
    int channel_data_size = sizeof(s->delay[0]);
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
    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;
729 730 731
    }
}

732 733
/**
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
734 735 736 737
 * 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.
 *
738 739 740 741 742 743 744 745 746 747 748 749 750
 * @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,
751
                                  int *num_bands, uint8_t *band_sizes)
752
{
753
    int subbnd, bnd, n_subbands, n_bands=0;
754
    uint8_t bnd_sz[22];
755 756
    uint8_t coded_band_struct[22];
    const uint8_t *band_struct;
757 758 759 760 761 762

    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++) {
763
            coded_band_struct[subbnd] = get_bits1(gbc);
764
        }
765
        band_struct = coded_band_struct;
766
    } else if (!blk) {
767 768 769 770
        band_struct = &default_band_struct[start_subband+1];
    } else {
        /* no change in band structure */
        return;
771 772 773 774 775 776
    }

    /* 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 ) {
777
        n_bands = n_subbands;
778 779 780
        bnd_sz[0] = ecpl ? 6 : 12;
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
781
            if (band_struct[subbnd - 1]) {
782 783 784 785 786 787 788 789 790 791 792 793
                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)
794
        memcpy(band_sizes, bnd_sz, n_bands);
795 796
}

797
/**
798
 * Decode a single audio block from the AC-3 bitstream.
799
 */
800
static int decode_audio_block(AC3DecodeContext *s, int blk)
801
{
802 803
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
804
    int i, bnd, seg, ch;
805 806
    int different_transforms;
    int downmix_output;
807
    int cpl_in_use;
808
    GetBitContext *gbc = &s->gbc;
809
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
810

811
    /* block switch flags */
812
    different_transforms = 0;
813
    if (s->block_switch_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
814 815
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->block_switch[ch] = get_bits1(gbc);
816
            if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
Justin Ruggles's avatar
Justin Ruggles committed
817 818
                different_transforms = 1;
        }
819
    }
820

821
    /* dithering flags */
822
    if (s->dither_flag_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
823 824 825
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->dither_flag[ch] = get_bits1(gbc);
        }
826
    }
827

828
    /* dynamic range */
829
    i = !s->channel_mode;
830
    do {
831
        if (get_bits1(gbc)) {
832 833
            /* Allow asymmetric application of DRC when drc_scale > 1.
               Amplification of quiet sounds is enhanced */
834 835 836
            int range_bits = get_bits(gbc, 8);
            INTFLOAT range = AC3_RANGE(range_bits);
            if (range_bits <= 127 || s->drc_scale <= 1.0)
837
                s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
838 839
            else
                s->dynamic_range[i] = range;
840
        } else if (blk == 0) {
841
            s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
842
        }
843
    } while (i--);
844

845 846
    /* spectral extension strategy */
    if (s->eac3 && (!blk || get_bits1(gbc))) {
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
        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;
867
#if USE_FIXED
868
            s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
869
#endif
870 871 872 873 874 875 876 877 878 879
            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);
880
                return AVERROR_INVALIDDATA;
881 882 883 884
            }
            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);
885
                return AVERROR_INVALIDDATA;
886 887 888 889
            }

            s->spx_dst_start_freq = dst_start_freq;
            s->spx_src_start_freq = src_start_freq;
890 891
            if (!USE_FIXED)
                s->spx_dst_end_freq   = dst_end_freq;
892 893 894 895 896 897

            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);
898 899 900 901 902 903 904
        }
    }
    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;
905 906 907
        }
    }

908 909 910 911 912
    /* 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)) {
913
                    INTFLOAT spx_blend;
914 915 916
                    int bin, master_spx_coord;

                    s->first_spx_coords[ch] = 0;
917
                    spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
918 919 920 921
                    master_spx_coord = get_bits(gbc, 2) * 3;

                    bin = s->spx_src_start_freq;
                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
Christophe Gisquet's avatar
Christophe Gisquet committed
922
                        int bandsize = s->spx_band_sizes[bnd];
923
                        int spx_coord_exp, spx_coord_mant;
924
                        INTFLOAT nratio, sblend, nblend;
925
#if USE_FIXED
926
                        /* calculate blending factors */
Christophe Gisquet's avatar
Christophe Gisquet committed
927 928
                        int64_t accu = ((bin << 23) + (bandsize << 22))
                                     * (int64_t)s->spx_dst_end_freq;
929 930 931 932 933 934 935
                        nratio = (int)(accu >> 32);
                        nratio -= spx_blend << 18;

                        if (nratio < 0) {
                            nblend = 0;
                            sblend = 0x800000;
                        } else if (nratio > 0x7fffff) {
936
                            nblend = 14529495; // sqrt(3) in FP.23
937 938 939 940 941 942 943 944 945
                            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;
946 947 948 949

                        /* calculate blending factors */
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
950 951
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
                                                       // to give unity variance
952
                        sblend = sqrtf(1.0f - nratio);
953
#endif
954 955 956 957 958 959 960 961 962 963
                        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);

                        /* multiply noise and signal blending factors by spx coordinate */
964
#if USE_FIXED
965 966 967 968 969 970
                        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));
971 972
                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
973
#endif
974 975 976 977 978 979 980
                    }
                }
            } else {
                s->first_spx_coords[ch] = 1;
            }
        }
    }
981

982
    /* coupling strategy */
983
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
984
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
985
        if (!s->eac3)
Justin Ruggles's avatar
Justin Ruggles committed
986
            s->cpl_in_use[blk] = get_bits1(gbc);
987
        if (s->cpl_in_use[blk]) {
988
            /* coupling in use */
989
            int cpl_start_subband, cpl_end_subband;
990

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

996 997 998
            /* check for enhanced coupling */
            if (s->eac3 && get_bits1(gbc)) {
                /* TODO: parse enhanced coupling strategy info */
999
                avpriv_request_sample(s->avctx, "Enhanced coupling");
1000
                return AVERROR_PATCHWELCOME;
1001 1002
            }

1003
            /* determine which channels are coupled */
1004 1005 1006 1007
            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
1008 1009
                for (ch = 1; ch <= fbw_channels; ch++)
                    s->channel_in_cpl[ch] = get_bits1(gbc);
1010
            }
1011

1012
            /* phase flags in use */
1013
            if (channel_mode == AC3_CHMODE_STEREO)
1014
                s->phase_flags_in_use = get_bits1(gbc);
1015

1016
            /* coupling frequency range */
1017
            cpl_start_subband = get_bits(gbc, 4);
1018 1019
            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
                                              get_bits(gbc, 4) + 3;
1020 1021
            if (cpl_start_subband >= cpl_end_subband) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1022
                       cpl_start_subband, cpl_end_subband);
1023
                return AVERROR_INVALIDDATA;
1024
            }
1025
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1026
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1027

1028 1029 1030
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
                                  cpl_end_subband,
                                  ff_eac3_default_cpl_band_struct,
1031
                                  &s->num_cpl_bands, s->cpl_band_sizes);
1032
        } else {
1033
            /* coupling not in use */
1034
            for (ch = 1; ch <= fbw_channels; ch++) {
1035
                s->channel_in_cpl[ch] = 0;
1036 1037
                s->first_cpl_coords[ch] = 1;
            }
1038
            s->first_cpl_leak = s->eac3;
1039
            s->phase_flags_in_use = 0;
1040
        }
1041
    } else if (!s->eac3) {
1042 1043 1044
        if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
                   "be present in block 0\n");
1045
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1046 1047 1048
        } else {
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
        }
1049
    }
1050
    cpl_in_use = s->cpl_in_use[blk];
1051

1052
    /* coupling coordinates */
1053
    if (cpl_in_use) {
1054
        int cpl_coords_exist = 0;
1055

1056
        for (ch = 1; ch <= fbw_channels; ch++) {
1057
            if (s->channel_in_cpl[ch]) {
1058
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1059
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1060
                    s->first_cpl_coords[ch] = 0;
1061
                    cpl_coords_exist = 1;
1062
                    master_cpl_coord = 3 * get_bits(gbc, 2);
1063
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1064 1065
                        cpl_coord_exp = get_bits(gbc, 4);
                        cpl_coord_mant = get_bits(gbc, 4);
1066
                        if (cpl_coord_exp == 15)
1067
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1068
                        else
1069 1070
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1071
                    }
1072
                } else if (!blk) {
1073 1074
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
                           "be present in block 0\n");
1075
                    return AVERROR_INVALIDDATA;
1076
                }
1077 1078 1079
            } else {
                /* channel not in coupling */
                s->first_cpl_coords[ch] = 1;
1080 1081
            }
        }
1082
        /* phase flags */
1083
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1084
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1085
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1086 1087
            }
        }
1088
    }
1089

1090
    /* stereo rematrixing strategy and band structure */
1091
    if (channel_mode == AC3_CHMODE_STEREO) {
1092
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1093
            s->num_rematrixing_bands = 4;
1094
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1095
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1096 1097 1098
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
                s->num_rematrixing_bands--;
            }
1099
            for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1100
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1101
        } else if (!blk) {
1102 1103
            av_log(s->avctx, AV_LOG_WARNING, "Warning: "
                   "new rematrixing strategy not present in block 0\n");
1104
            s->num_rematrixing_bands = 0;
1105
        }
1106 1107
    }

1108
    /* exponent strategies for each channel */
1109
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1110
        if (!s->eac3)
1111
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1112
        if (s->exp_strategy[blk][ch] != EXP_REUSE)
1113 1114 1115
            bit_alloc_stages[ch] = 3;
    }

1116
    /* channel bandwidth */
1117
    for (ch = 1; ch <= fbw_channels; ch++) {
1118
        s->start_freq[ch] = 0;
1119
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1120
            int group_size;
1121 1122 1123
            int prev = s->end_freq[ch];
            if (s->channel_in_cpl[ch])
                s->end_freq[ch] = s->start_freq[CPL_CH];
1124 1125
            else if (s->channel_uses_spx[ch])
                s->end_freq[ch] = s->spx_src_start_freq;
1126
            else {
1127
                int bandwidth_code = get_bits(gbc, 6);
1128
                if (bandwidth_code > 60) {
1129
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1130
                    return AVERROR_INVALIDDATA;
1131
                }
1132
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1133
            }
1134
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1135 1136
            s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
            if (blk > 0 && s->end_freq[ch] != prev)
1137
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1138
        }
1139
    }
1140
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1141
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1142
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1143
    }
1144

1145
    /* decode exponents for each channel */
1146
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1147
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1148
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1149
            if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1150 1151
                                 s->num_exp_groups[ch], s->dexps[ch][0],
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1152
                return AVERROR_INVALIDDATA;
1153
            }
1154
            if (ch != CPL_CH && ch != s->lfe_ch)
1155
                skip_bits(gbc, 2); /* skip gainrng */
1156
        }
1157
    }
1158

1159
    /* bit allocation information */
1160
    if (s->bit_allocation_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
1161 1162 1163 1164 1165
        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)];
1166
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1167
            for (ch = !cpl_in_use; ch <= s->channels; ch++)
Justin Ruggles's avatar
Justin Ruggles committed
1168 1169
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
        } else if (!blk) {
1170 1171
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
                   "be present in block 0\n");
1172
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1173
        }
1174
    }
1175

1176
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1177 1178
    if (!s->eac3 || !blk) {
        if (s->snr_offset_strategy && get_bits1(gbc)) {
Justin Ruggles's avatar
Justin Ruggles committed
1179 1180 1181 1182 1183 1184 1185 1186
            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 */
1187
                if (blk && s->snr_offset[ch] != snr) {
Justin Ruggles's avatar
Justin Ruggles committed
1188 1189 1190
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
                }
                s->snr_offset[ch] = snr;
1191 1192 1193 1194

                /* fast gain (normal AC-3 only) */
                if (!s->eac3) {
                    int prev = s->fast_gain[ch];
Justin Ruggles's avatar
Justin Ruggles committed
1195
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1196
                    /* run last 2 bit allocation stages if fast gain changes */
1197
                    if (blk && prev != s->fast_gain[ch])
1198 1199
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
                }
Justin Ruggles's avatar
Justin Ruggles committed
1200
            }
1201
        } else if (!s->eac3 && !blk) {
Justin Ruggles's avatar
Justin Ruggles committed
1202
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1203
            return AVERROR_INVALIDDATA;
1204
        }
1205
    }
1206

1207 1208 1209 1210 1211 1212
    /* 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 */
1213
            if (blk && prev != s->fast_gain[ch])
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
                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
    }

1226
    /* coupling leak information */
1227
    if (cpl_in_use) {
1228 1229 1230 1231 1232
        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 */
1233 1234
            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
1235
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1236 1237 1238 1239
            }
            s->bit_alloc_params.cpl_fast_leak = fl;
            s->bit_alloc_params.cpl_slow_leak = sl;
        } else if (!s->eac3 && !blk) {
1240 1241
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
                   "be present in block 0\n");
1242
            return AVERROR_INVALIDDATA;
Justin Ruggles's avatar
Justin Ruggles committed
1243
        }
1244
        s->first_cpl_leak = 0;
1245
    }
1246

1247
    /* delta bit allocation information */
1248
    if (s->dba_syntax && get_bits1(gbc)) {
1249
        /* delta bit allocation exists (strategy) */
1250
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1251 1252 1253
            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");
1254
                return AVERROR_INVALIDDATA;
1255
            }
1256
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1257
        }
1258
        /* channel delta offset, len and bit allocation */
1259
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1260
            if (s->dba_mode[ch] == DBA_NEW) {
1261 1262
                s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
                for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1263 1264
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1265
                    s->dba_values[ch][seg]  = get_bits(gbc, 3);
1266
                }
1267 1268
                /* run last 2 bit allocation stages if new dba values */
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1269
            }
1270
        }
1271 1272
    } else if (blk == 0) {
        for (ch = 0; ch <= s->channels; ch++) {
1273
            s->dba_mode[ch] = DBA_NONE;
1274
        }
1275
    }
1276

1277
    /* Bit allocation */
1278 1279
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
        if (bit_alloc_stages[ch] > 2) {
1280
            /* Exponent mapping into PSD and PSD integration */
1281 1282 1283
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->psd[ch], s->band_psd[ch]);
1284
        }
1285
        if (bit_alloc_stages[ch] > 1) {
1286 1287
            /* Compute excitation function, Compute masking curve, and
               Apply delta bit allocation */
1288
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1289 1290 1291
                                           s->start_freq[ch],  s->end_freq[ch],
                                           s->fast_gain[ch],   (ch == s->lfe_ch),
                                           s->dba_mode[ch],    s->dba_nsegs[ch],
1292
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1293
                                           s->dba_values[ch],  s->mask[ch])) {
1294
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1295
                return AVERROR_INVALIDDATA;
1296
            }
1297
        }
1298
        if (bit_alloc_stages[ch] > 0) {
1299
            /* Compute bit allocation */
1300 1301
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1302
            s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1303 1304 1305
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->snr_offset[ch],
                                      s->bit_alloc_params.floor,
1306
                                      bap_tab, s->bap[ch]);
1307
        }
1308
    }
1309

1310
    /* unused dummy data */
1311
    if (s->skip_syntax && get_bits1(gbc)) {
1312
        int skipl = get_bits(gbc, 9);
1313
        while (skipl--)
1314
            skip_bits(gbc, 8);
1315
    }
1316

1317
    /* unpack the transform coefficients
1318
       this also uncouples channels if coupling is in use. */
1319
    decode_transform_coeffs(s, blk);
1320

1321 1322
    /* TODO: generate enhanced coupling coordinates and uncouple */

1323
    /* recover coefficients if rematrixing is in use */
1324
    if (s->channel_mode == AC3_CHMODE_STEREO)
1325
        do_rematrixing(s);
1326

1327
    /* apply scaling to coefficients (headroom, dynrng) */
1328
    for (ch = 1; ch <= s->channels; ch++) {
1329
        int audio_channel = 0;
1330
        INTFLOAT gain;
1331 1332 1333 1334 1335 1336 1337
        if (s->channel_mode == AC3_CHMODE_DUALMONO)
            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];

1338
#if USE_FIXED
1339 1340
        scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
#else
1341 1342
        if (s->target_level != 0)
          gain = gain * s->level_gain[audio_channel];
1343
        gain *= 1.0 / 4194304.0f;
1344 1345
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
                                               s->fixed_coeffs[ch], gain, 256);
1346
#endif
1347
    }
1348

1349
    /* apply spectral extension to high frequency bins */
1350
    if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1351 1352 1353
        ff_eac3_apply_spectral_extension(s);
    }

1354 1355 1356 1357 1358 1359
    /* 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);
1360
    if (different_transforms) {
1361 1362
        /* the delay samples have already been downmixed, so we upmix the delay
           samples in order to reconstruct all channels before downmixing. */
1363
        if (s->downmixed) {
1364 1365 1366 1367 1368 1369
            s->downmixed = 0;
            ac3_upmix_delay(s);
        }

        do_imdct(s, s->channels);

1370
        if (downmix_output) {
1371
#if USE_FIXED
1372 1373 1374
            ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
                              s->out_channels, s->fbw_channels, 256);
#else
1375
            s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1376
                              s->out_channels, s->fbw_channels, 256);
1377
#endif
1378 1379
        }
    } else {
1380
        if (downmix_output) {
1381 1382
            s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
                                          s->out_channels, s->fbw_channels, 256);
1383 1384
        }

1385
        if (downmix_output && !s->downmixed) {
1386
            s->downmixed = 1;
1387 1388
            s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
                                          s->out_channels, s->fbw_channels, 128);
1389
        }
1390

1391
        do_imdct(s, s->out_channels);
1392 1393
    }

1394
    return 0;
1395 1396
}

1397 1398
/**
 * Decode a single AC-3 frame.
1399
 */
1400 1401
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
                            int *got_frame_ptr, AVPacket *avpkt)
1402
{
1403
    AVFrame *frame     = data;
1404 1405
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
1406
    AC3DecodeContext *s = avctx->priv_data;
1407
    int blk, ch, err, ret;
1408
    const uint8_t *channel_map;
1409
    const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1410
    enum AVMatrixEncoding matrix_encoding;
1411
    AVDownmixInfo *downmix_info;
1412

Justin Ruggles's avatar
Justin Ruggles committed
1413 1414
    /* copy input buffer to decoder context to avoid reading past the end
       of the buffer, which can be caused by a damaged input stream. */
1415 1416 1417
    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;
1418 1419
        s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
                            (const uint16_t *) buf, cnt);
1420
    } else
1421
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1422 1423
    buf = s->input_buffer;
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1424 1425
    if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
        return ret;
1426

1427
    /* parse the syncinfo */
1428
    err = parse_frame_header(s);
1429

1430
    if (err) {
1431 1432 1433
        switch (err) {
        case AAC_AC3_PARSE_ERROR_SYNC:
            av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1434
            return AVERROR_INVALIDDATA;
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
        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) {
1448 1449 1450
                av_log(avctx, AV_LOG_DEBUG,
                       "unsupported frame type %d: skipping frame\n",
                       s->frame_type);
1451
                *got_frame_ptr = 0;
1452
                return buf_size;
1453 1454 1455 1456
            } else {
                av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
            }
            break;
1457 1458
        case AAC_AC3_PARSE_ERROR_CRC:
        case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1459
            break;
1460 1461 1462
        default: // Normal AVERROR do not try to recover.
            *got_frame_ptr = 0;
            return err;
1463
        }
1464 1465 1466 1467 1468
    } 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;
1469
        } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1470
            /* check for crc mismatch */
1471 1472
            if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
                       s->frame_size - 2)) {
1473
                av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1474 1475
                if (avctx->err_recognition & AV_EF_EXPLODE)
                    return AVERROR_INVALIDDATA;
1476 1477 1478
                err = AAC_AC3_PARSE_ERROR_CRC;
            }
        }
1479
    }
1480

1481 1482
    /* if frame is ok, set audio parameters */
    if (!err) {
Justin Ruggles's avatar
Justin Ruggles committed
1483
        avctx->sample_rate = s->sample_rate;
1484
        avctx->bit_rate    = s->bit_rate;
1485
    }
Justin Ruggles's avatar
Justin Ruggles committed
1486

1487 1488
    /* channel config */
    if (!err || (s->channels && s->out_channels != s->channels)) {
Justin Ruggles's avatar
Justin Ruggles committed
1489
        s->out_channels = s->channels;
1490 1491
        s->output_mode  = s->channel_mode;
        if (s->lfe_on)
1492
            s->output_mode |= AC3_OUTPUT_LFEON;
1493 1494 1495 1496 1497 1498 1499 1500
        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
1501
        }
1502

1503 1504
        s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
        s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1505 1506
        s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
        s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
Justin Ruggles's avatar
Justin Ruggles committed
1507
        /* set downmixing coefficients if needed */
1508
        if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
Justin Ruggles's avatar
Justin Ruggles committed
1509 1510 1511
                s->fbw_channels == s->out_channels)) {
            set_downmix_coeffs(s);
        }
1512 1513
    } else if (!s->channels) {
        av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1514 1515
        return AVERROR_INVALIDDATA;
    }
1516
    avctx->channels = s->out_channels;
1517 1518 1519
    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;
1520

1521 1522 1523 1524
    /* 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;
1525

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

1531
    /* decode the audio blocks */
1532
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1533 1534
    for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
        output[ch] = s->output[ch];
1535
        s->outptr[ch] = s->output[ch];
1536
    }
1537 1538
    for (ch = 0; ch < s->channels; ch++) {
        if (ch < s->out_channels)
1539
            s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1540
    }
1541
    for (blk = 0; blk < s->num_blocks; blk++) {
1542 1543
        if (!err && decode_audio_block(s, blk)) {
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1544
            err = 1;
1545
        }
1546 1547
        if (err)
            for (ch = 0; ch < s->out_channels; ch++)
1548
                memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1549
        for (ch = 0; ch < s->out_channels; ch++)
1550
            output[ch] = s->outptr[channel_map[ch]];
1551
        for (ch = 0; ch < s->out_channels; ch++) {
1552 1553
            if (!ch || channel_map[ch])
                s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1554
        }
1555
    }
1556

1557
    av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1558

1559 1560
    /* keep last block for error concealment in next frame */
    for (ch = 0; ch < s->out_channels; ch++)
1561
        memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1562

1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
    /*
     * 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;

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
    /* 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);

1619
    *got_frame_ptr = 1;
1620

1621
    return FFMIN(buf_size, s->frame_size);
1622
}
1623

1624 1625
/**
 * Uninitialize the AC-3 decoder.
1626
 */
1627
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1628
{
1629
    AC3DecodeContext *s = avctx->priv_data;
1630 1631
    ff_mdct_end(&s->imdct_512);
    ff_mdct_end(&s->imdct_256);
1632
    av_freep(&s->fdsp);
1633

1634 1635 1636
    return 0;
}

1637 1638
#define OFFSET(x) offsetof(AC3DecodeContext, x)
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)