ac3dec.c 54 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 Libav.
11
 *
12
 * Libav 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
 * Libav 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 Libav; 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/crc.h"
33
#include "libavutil/opt.h"
34
#include "internal.h"
35
#include "aac_ac3_parser.h"
36
#include "ac3_parser.h"
37
#include "ac3dec.h"
38
#include "ac3dec_data.h"
39
#include "kbdwin.h"
40

41 42 43 44 45
/**
 * 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];
46

47
/** tables for ungrouping mantissas */
48 49 50 51 52
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];
53

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

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

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

79 80 81 82 83
/**
 * 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] = {
84 85 86 87 88 89 90 91
    { { 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 }, },
92
};
93

94 95 96 97 98
/**
 * Symmetrical Dequantization
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 *            Tables 7.19 to 7.23
 */
99
static inline int
100
symmetric_dequant(int code, int levels)
101
{
102
    return ((code - (levels >> 1)) << 24) / levels;
103 104
}

105 106 107
/*
 * Initialize tables at runtime.
 */
108
static av_cold void ac3_tables_init(void)
109
{
110
    int i;
111

112 113
    /* generate table for ungrouping 3 values in 7 bits
       reference: Section 7.1.3 Exponent Decoding */
114
    for (i = 0; i < 128; i++) {
115 116 117 118 119
        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;
    }

120 121
    /* generate grouped mantissa tables
       reference: Section 7.3.5 Ungrouping of Mantissas */
122
    for (i = 0; i < 32; i++) {
123
        /* bap=1 mantissas */
124 125 126
        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);
127
    }
128
    for (i = 0; i < 128; i++) {
129
        /* bap=2 mantissas */
130 131 132
        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);
133 134 135 136 137 138 139

        /* 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 */
140
    for (i = 0; i < 7; i++) {
141 142 143
        /* bap=3 mantissas */
        b3_mantissas[i] = symmetric_dequant(i, 7);
    }
144
    for (i = 0; i < 15; i++) {
145 146 147
        /* bap=5 mantissas */
        b5_mantissas[i] = symmetric_dequant(i, 15);
    }
148

149 150
    /* generate dynamic range table
       reference: Section 7.7.1 Dynamic Range Control */
151
    for (i = 0; i < 256; i++) {
152
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
153
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
154
    }
155 156
}

157 158 159
/**
 * AVCodec initialization
 */
160
static av_cold int ac3_decode_init(AVCodecContext *avctx)
161
{
162 163
    AC3DecodeContext *s = avctx->priv_data;
    s->avctx = avctx;
164

165
    ff_ac3_common_init();
166
    ac3_tables_init();
167 168
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
169
    ff_kbd_window_init(s->window, 5.0, 256);
170
    ff_dsputil_init(&s->dsp, avctx);
171
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
172
    ff_fmt_convert_init(&s->fmt_conv, avctx);
173
    av_lfg_init(&s->dith_state, 0);
174

175
    /* set scale value for float to int16 conversion */
176 177 178 179 180 181 182
    if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
        s->mul_bias = 1.0f;
        avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
    } else {
        s->mul_bias = 32767.0f;
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
    }
183

184 185 186 187 188 189
    /* allow downmixing to stereo or mono */
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
            avctx->request_channels < avctx->channels &&
            avctx->request_channels <= 2) {
        avctx->channels = avctx->request_channels;
    }
190
    s->downmixed = 1;
191

192 193 194
    avcodec_get_frame_defaults(&s->frame);
    avctx->coded_frame = &s->frame;

195
    return 0;
196 197
}

198
/**
199
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
200
 * GetBitContext within AC3DecodeContext must point to
201
 * the start of the synchronized AC-3 bitstream.
202
 */
203
static int ac3_parse_header(AC3DecodeContext *s)
204 205 206 207 208
{
    GetBitContext *gbc = &s->gbc;
    int i;

    /* read the rest of the bsi. read twice for dual mono mode. */
209
    i = !s->channel_mode;
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
    do {
        skip_bits(gbc, 5); // skip dialog normalization
        if (get_bits1(gbc))
            skip_bits(gbc, 8); //skip compression
        if (get_bits1(gbc))
            skip_bits(gbc, 8); //skip language code
        if (get_bits1(gbc))
            skip_bits(gbc, 7); //skip audio production information
    } while (i--);

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

    /* skip the timecodes (or extra bitstream information for Alternate Syntax)
       TODO: read & use the xbsi1 downmix levels */
    if (get_bits1(gbc))
        skip_bits(gbc, 14); //skip timecode1 / xbsi1
    if (get_bits1(gbc))
        skip_bits(gbc, 14); //skip timecode2 / xbsi2

    /* skip additional bitstream info */
    if (get_bits1(gbc)) {
        i = get_bits(gbc, 6);
        do {
            skip_bits(gbc, 8);
234
        } while (i--);
235 236 237 238 239 240
    }

    return 0;
}

/**
241
 * Common function to parse AC-3 or E-AC-3 frame header
242 243
 */
static int parse_frame_header(AC3DecodeContext *s)
244
{
245
    AC3HeaderInfo hdr;
246
    int err;
247

248
    err = avpriv_ac3_parse_header(&s->gbc, &hdr);
249
    if (err)
250 251 252
        return err;

    /* get decoding parameters from header info */
253
    s->bit_alloc_params.sr_code     = hdr.sr_code;
254
    s->bitstream_mode               = hdr.bitstream_mode;
255
    s->channel_mode                 = hdr.channel_mode;
256
    s->channel_layout               = hdr.channel_layout;
257
    s->lfe_on                       = hdr.lfe_on;
258
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
259
    s->sample_rate                  = hdr.sample_rate;
260 261 262 263 264
    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;
265 266
    s->center_mix_level             = hdr.center_mix_level;
    s->surround_mix_level           = hdr.surround_mix_level;
267
    s->num_blocks                   = hdr.num_blocks;
268
    s->frame_type                   = hdr.frame_type;
269
    s->substreamid                  = hdr.substreamid;
270

271 272 273
    if (s->lfe_on) {
        s->start_freq[s->lfe_ch]     = 0;
        s->end_freq[s->lfe_ch]       = 7;
274 275 276 277
        s->num_exp_groups[s->lfe_ch] = 2;
        s->channel_in_cpl[s->lfe_ch] = 0;
    }

278 279 280 281 282 283 284 285 286 287 288
    if (hdr.bitstream_id <= 10) {
        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
289
        return ac3_parse_header(s);
290
    } else if (CONFIG_EAC3_DECODER) {
291 292
        s->eac3 = 1;
        return ff_eac3_parse_header(s);
293 294 295
    } else {
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
        return -1;
296
    }
297 298 299 300 301 302 303 304 305
}

/**
 * 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;
306 307
    float cmix = gain_levels[s->  center_mix_level];
    float smix = gain_levels[s->surround_mix_level];
Loren Merritt's avatar
Loren Merritt committed
308
    float norm0, norm1;
309

310
    for (i = 0; i < s->fbw_channels; i++) {
311 312
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
313
    }
314
    if (s->channel_mode > 1 && s->channel_mode & 1) {
315
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
316
    }
317
    if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
318
        int nf = s->channel_mode - 2;
319
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
320
    }
321
    if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
322
        int nf = s->channel_mode - 4;
323
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
324
    }
325

Loren Merritt's avatar
Loren Merritt committed
326 327
    /* renormalize */
    norm0 = norm1 = 0.0;
328
    for (i = 0; i < s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
329 330 331 332 333
        norm0 += s->downmix_coeffs[i][0];
        norm1 += s->downmix_coeffs[i][1];
    }
    norm0 = 1.0f / norm0;
    norm1 = 1.0f / norm1;
334
    for (i = 0; i < s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
335 336 337 338
        s->downmix_coeffs[i][0] *= norm0;
        s->downmix_coeffs[i][1] *= norm1;
    }

339 340 341 342
    if (s->output_mode == AC3_CHMODE_MONO) {
        for (i = 0; i < s->fbw_channels; i++)
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
                                       s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
343
    }
344 345
}

346
/**
347 348
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
349
 */
350
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
351
                            uint8_t absexp, int8_t *dexps)
352
{
353
    int i, j, grp, group_size;
354 355 356 357
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
358
    group_size = exp_strategy + (exp_strategy == EXP_D45);
359
    for (grp = 0, i = 0; grp < ngrps; grp++) {
360
        expacc = get_bits(gbc, 7);
361 362 363
        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];
364
    }
365

366 367
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
368
    for (i = 0, j = 0; i < ngrps * 3; i++) {
369
        prevexp += dexp[i] - 2;
370
        if (prevexp > 24U)
371
            return -1;
372
        switch (group_size) {
373 374 375 376
        case 4: dexps[j++] = prevexp;
                dexps[j++] = prevexp;
        case 2: dexps[j++] = prevexp;
        case 1: dexps[j++] = prevexp;
377
        }
378
    }
379
    return 0;
380 381
}

382
/**
383
 * Generate transform coefficients for each coupled channel in the coupling
384 385 386
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
387
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
388
{
389
    int bin, band, ch;
390 391 392

    bin = s->start_freq[CPL_CH];
    for (band = 0; band < s->num_cpl_bands; band++) {
393
        int band_start = bin;
394
        int band_end = bin + s->cpl_band_sizes[band];
395 396
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (s->channel_in_cpl[ch]) {
397
                int cpl_coord = s->cpl_coords[ch][band] << 5;
398
                for (bin = band_start; bin < band_end; bin++) {
399 400
                    s->fixed_coeffs[ch][bin] =
                        MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
401 402 403 404
                }
                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];
405
                }
406
            }
407
        }
408
        bin = band_end;
409 410 411
    }
}

412 413 414 415
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
typedef struct {
416 417 418 419 420 421
    int b1_mant[2];
    int b2_mant[2];
    int b4_mant;
    int b1;
    int b2;
    int b4;
422 423
} mant_groups;

424
/**
425
 * Decode the transform coefficients for a particular channel
426 427
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
428
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
429
{
430
    int start_freq = s->start_freq[ch_index];
431 432 433 434 435
    int end_freq   = s->end_freq[ch_index];
    uint8_t *baps  = s->bap[ch_index];
    int8_t *exps   = s->dexps[ch_index];
    int *coeffs    = s->fixed_coeffs[ch_index];
    int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
436
    GetBitContext *gbc = &s->gbc;
437
    int freq;
438

439
    for (freq = start_freq; freq < end_freq; freq++) {
440 441
        int bap = baps[freq];
        int mantissa;
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
        switch (bap) {
        case 0:
            if (dither)
                mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
            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. */
            mantissa = get_sbits(gbc, quantization_tab[bap]);
            mantissa <<= 24 - quantization_tab[bap];
            break;
495
        }
496
        coeffs[freq] = mantissa >> exps[freq];
497 498 499
    }
}

500
/**
501 502
 * Remove random dithering from coupling range coefficients with zero-bit
 * mantissas for coupled channels which do not use dithering.
503 504
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
505
static void remove_dithering(AC3DecodeContext *s) {
506 507
    int ch, i;

508 509 510 511
    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])
512
                    s->fixed_coeffs[ch][i] = 0;
513 514 515 516 517
            }
        }
    }
}

518
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
519
                                       mant_groups *m)
520 521
{
    if (!s->channel_uses_aht[ch]) {
522
        ac3_decode_transform_coeffs_ch(s, ch, m);
523 524 525 526
    } else {
        /* if AHT is used, mantissas for all blocks are encoded in the first
           block of the frame. */
        int bin;
527
        if (!blk && CONFIG_EAC3_DECODER)
528
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
529
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
530
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
531 532 533 534
        }
    }
}

535
/**
536
 * Decode the transform coefficients.
537
 */
538
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
539
{
540
    int ch, end;
541
    int got_cplchan = 0;
542 543
    mant_groups m;

544
    m.b1 = m.b2 = m.b4 = 0;
545

546
    for (ch = 1; ch <= s->channels; ch++) {
547
        /* transform coefficients for full-bandwidth channel */
548
        decode_transform_coeffs_ch(s, blk, ch, &m);
549 550
        /* tranform coefficients for coupling channel come right after the
           coefficients for the first coupled channel*/
551
        if (s->channel_in_cpl[ch])  {
552
            if (!got_cplchan) {
553
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
554
                calc_transform_coeffs_cpl(s);
555 556
                got_cplchan = 1;
            }
557
            end = s->end_freq[CPL_CH];
558
        } else {
559
            end = s->end_freq[ch];
560
        }
561
        do
562
            s->fixed_coeffs[ch][end] = 0;
563
        while (++end < 256);
564
    }
565

566
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
567
    remove_dithering(s);
568 569
}

570
/**
571
 * Stereo rematrixing.
572 573
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
574
static void do_rematrixing(AC3DecodeContext *s)
575
{
576
    int bnd, i;
577 578
    int end, bndend;

579
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
580

581 582 583 584
    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++) {
585
                int tmp0 = s->fixed_coeffs[1][i];
586
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
587
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
588 589
            }
        }
590 591
    }
}
592

593 594 595 596 597
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
598
static inline void do_imdct(AC3DecodeContext *s, int channels)
599
{
Justin Ruggles's avatar
Justin Ruggles committed
600
    int ch;
601

602
    for (ch = 1; ch <= channels; ch++) {
603
        if (s->block_switch[ch]) {
Loren Merritt's avatar
Loren Merritt committed
604
            int i;
605 606 607
            float *x = s->tmp_output + 128;
            for (i = 0; i < 128; i++)
                x[i] = s->transform_coeffs[ch][2 * i];
608
            s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
609 610 611 612 613
            s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
                                      s->tmp_output, s->window, 128);
            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);
614
        } else {
615
            s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
616 617 618
            s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
                                      s->tmp_output, s->window, 128);
            memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
619
        }
620 621 622
    }
}

623
/**
624
 * Downmix the output to mono or stereo.
625
 */
626 627
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2],
                      int out_ch, int in_ch, int len)
628 629
{
    int i, j;
630
    float v0, v1;
631 632
    if (out_ch == 2) {
        for (i = 0; i < len; i++) {
Loren Merritt's avatar
Loren Merritt committed
633
            v0 = v1 = 0.0f;
634
            for (j = 0; j < in_ch; j++) {
Loren Merritt's avatar
Loren Merritt committed
635 636
                v0 += samples[j][i] * matrix[j][0];
                v1 += samples[j][i] * matrix[j][1];
Loren Merritt's avatar
Loren Merritt committed
637 638 639
            }
            samples[0][i] = v0;
            samples[1][i] = v1;
640
        }
641 642
    } else if (out_ch == 1) {
        for (i = 0; i < len; i++) {
Loren Merritt's avatar
Loren Merritt committed
643
            v0 = 0.0f;
644
            for (j = 0; j < in_ch; j++)
Loren Merritt's avatar
Loren Merritt committed
645
                v0 += samples[j][i] * matrix[j][0];
Loren Merritt's avatar
Loren Merritt committed
646
            samples[0][i] = v0;
647 648 649 650
        }
    }
}

651 652 653 654 655
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
656
    int channel_data_size = sizeof(s->delay[0]);
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
    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;
676 677 678
    }
}

679 680
/**
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
681 682 683 684
 * 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.
 *
685 686 687 688 689 690 691 692 693 694 695 696 697
 * @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,
698
                                  int *num_bands, uint8_t *band_sizes)
699
{
700
    int subbnd, bnd, n_subbands, n_bands=0;
701
    uint8_t bnd_sz[22];
702 703
    uint8_t coded_band_struct[22];
    const uint8_t *band_struct;
704 705 706 707 708 709

    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++) {
710
            coded_band_struct[subbnd] = get_bits1(gbc);
711
        }
712
        band_struct = coded_band_struct;
713
    } else if (!blk) {
714 715 716 717
        band_struct = &default_band_struct[start_subband+1];
    } else {
        /* no change in band structure */
        return;
718 719 720 721 722 723
    }

    /* 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 ) {
724
        n_bands = n_subbands;
725 726 727
        bnd_sz[0] = ecpl ? 6 : 12;
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
728
            if (band_struct[subbnd - 1]) {
729 730 731 732 733 734 735 736 737 738 739 740
                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)
741
        memcpy(band_sizes, bnd_sz, n_bands);
742 743
}

744
/**
745
 * Decode a single audio block from the AC-3 bitstream.
746
 */
747
static int decode_audio_block(AC3DecodeContext *s, int blk)
748
{
749 750
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
751
    int i, bnd, seg, ch;
752 753
    int different_transforms;
    int downmix_output;
754
    int cpl_in_use;
755
    GetBitContext *gbc = &s->gbc;
756
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
757

758 759
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

760
    /* block switch flags */
761
    different_transforms = 0;
762
    if (s->block_switch_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
763 764
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->block_switch[ch] = get_bits1(gbc);
765
            if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
Justin Ruggles's avatar
Justin Ruggles committed
766 767
                different_transforms = 1;
        }
768
    }
769

770
    /* dithering flags */
771
    if (s->dither_flag_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
772 773 774
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->dither_flag[ch] = get_bits1(gbc);
        }
775
    }
776

777
    /* dynamic range */
778
    i = !s->channel_mode;
779
    do {
780 781 782 783
        if (get_bits1(gbc)) {
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
                                  s->drc_scale) + 1.0;
        } else if (blk == 0) {
784
            s->dynamic_range[i] = 1.0f;
785
        }
786
    } while (i--);
787

788 789
    /* spectral extension strategy */
    if (s->eac3 && (!blk || get_bits1(gbc))) {
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
        s->spx_in_use = get_bits1(gbc);
        if (s->spx_in_use) {
            int dst_start_freq, dst_end_freq, src_start_freq,
                start_subband, end_subband;

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

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

            /* check validity of spx ranges */
            if (start_subband >= end_subband) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
                       "range (%d >= %d)\n", start_subband, end_subband);
                return -1;
            }
            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 -1;
            }

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

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

845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
    /* spectral extension coordinates */
    if (s->spx_in_use) {
        for (ch = 1; ch <= fbw_channels; ch++) {
            if (s->channel_uses_spx[ch]) {
                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
                    float spx_blend;
                    int bin, master_spx_coord;

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

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

                        /* calculate blending factors */
                        bandsize = s->spx_band_sizes[bnd];
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
867 868
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
                                                       // to give unity variance
869 870 871 872 873 874 875 876 877
                        sblend = sqrtf(1.0f - nratio);
                        bin += bandsize;

                        /* decode spx coordinates */
                        spx_coord_exp  = get_bits(gbc, 4);
                        spx_coord_mant = get_bits(gbc, 2);
                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
                        else                     spx_coord_mant += 4;
                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
878
                        spx_coord = spx_coord_mant * (1.0f / (1 << 23));
879 880 881 882 883 884 885 886 887 888 889

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

891
    /* coupling strategy */
892
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
893
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
894
        if (!s->eac3)
Justin Ruggles's avatar
Justin Ruggles committed
895
            s->cpl_in_use[blk] = get_bits1(gbc);
896
        if (s->cpl_in_use[blk]) {
897
            /* coupling in use */
898
            int cpl_start_subband, cpl_end_subband;
899

900 901 902 903 904
            if (channel_mode < AC3_CHMODE_STEREO) {
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
                return -1;
            }

905 906 907
            /* check for enhanced coupling */
            if (s->eac3 && get_bits1(gbc)) {
                /* TODO: parse enhanced coupling strategy info */
908
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
909 910 911
                return -1;
            }

912
            /* determine which channels are coupled */
913 914 915 916
            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
917 918
                for (ch = 1; ch <= fbw_channels; ch++)
                    s->channel_in_cpl[ch] = get_bits1(gbc);
919
            }
920

921
            /* phase flags in use */
922
            if (channel_mode == AC3_CHMODE_STEREO)
923
                s->phase_flags_in_use = get_bits1(gbc);
924

925
            /* coupling frequency range */
926
            cpl_start_subband = get_bits(gbc, 4);
927 928
            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
                                              get_bits(gbc, 4) + 3;
929 930
            if (cpl_start_subband >= cpl_end_subband) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
931
                       cpl_start_subband, cpl_end_subband);
932
                return -1;
933
            }
934
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
935
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
936

937 938 939
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
                                  cpl_end_subband,
                                  ff_eac3_default_cpl_band_struct,
940
                                  &s->num_cpl_bands, s->cpl_band_sizes);
941
        } else {
942
            /* coupling not in use */
943
            for (ch = 1; ch <= fbw_channels; ch++) {
944
                s->channel_in_cpl[ch] = 0;
945 946
                s->first_cpl_coords[ch] = 1;
            }
947
            s->first_cpl_leak = s->eac3;
948
            s->phase_flags_in_use = 0;
949
        }
950
    } else if (!s->eac3) {
951 952 953
        if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
                   "be present in block 0\n");
Justin Ruggles's avatar
Justin Ruggles committed
954 955 956 957
            return -1;
        } else {
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
        }
958
    }
959
    cpl_in_use = s->cpl_in_use[blk];
960

961
    /* coupling coordinates */
962
    if (cpl_in_use) {
963
        int cpl_coords_exist = 0;
964

965
        for (ch = 1; ch <= fbw_channels; ch++) {
966
            if (s->channel_in_cpl[ch]) {
967
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
968
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
969
                    s->first_cpl_coords[ch] = 0;
970
                    cpl_coords_exist = 1;
971
                    master_cpl_coord = 3 * get_bits(gbc, 2);
972
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
973 974
                        cpl_coord_exp = get_bits(gbc, 4);
                        cpl_coord_mant = get_bits(gbc, 4);
975
                        if (cpl_coord_exp == 15)
976
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
977
                        else
978 979
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
980
                    }
981
                } else if (!blk) {
982 983
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
                           "be present in block 0\n");
984
                    return -1;
985
                }
986 987 988
            } else {
                /* channel not in coupling */
                s->first_cpl_coords[ch] = 1;
989 990
            }
        }
991
        /* phase flags */
992
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
993
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
994
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
995 996
            }
        }
997
    }
998

999
    /* stereo rematrixing strategy and band structure */
1000
    if (channel_mode == AC3_CHMODE_STEREO) {
1001
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1002
            s->num_rematrixing_bands = 4;
1003
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1004
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1005 1006 1007
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
                s->num_rematrixing_bands--;
            }
1008
            for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1009
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1010
        } else if (!blk) {
1011 1012
            av_log(s->avctx, AV_LOG_WARNING, "Warning: "
                   "new rematrixing strategy not present in block 0\n");
1013
            s->num_rematrixing_bands = 0;
1014
        }
1015 1016
    }

1017
    /* exponent strategies for each channel */
1018
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1019
        if (!s->eac3)
1020
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1021
        if (s->exp_strategy[blk][ch] != EXP_REUSE)
1022 1023 1024
            bit_alloc_stages[ch] = 3;
    }

1025
    /* channel bandwidth */
1026
    for (ch = 1; ch <= fbw_channels; ch++) {
1027
        s->start_freq[ch] = 0;
1028
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1029
            int group_size;
1030 1031 1032
            int prev = s->end_freq[ch];
            if (s->channel_in_cpl[ch])
                s->end_freq[ch] = s->start_freq[CPL_CH];
1033 1034
            else if (s->channel_uses_spx[ch])
                s->end_freq[ch] = s->spx_src_start_freq;
1035
            else {
1036
                int bandwidth_code = get_bits(gbc, 6);
1037
                if (bandwidth_code > 60) {
1038
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1039 1040
                    return -1;
                }
1041
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1042
            }
1043
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1044 1045
            s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
            if (blk > 0 && s->end_freq[ch] != prev)
1046
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1047
        }
1048
    }
1049
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1050
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1051
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1052
    }
1053

1054
    /* decode exponents for each channel */
1055
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1056
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1057
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1058
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1059 1060
                                 s->num_exp_groups[ch], s->dexps[ch][0],
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1061 1062 1063
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
                return -1;
            }
1064
            if (ch != CPL_CH && ch != s->lfe_ch)
1065
                skip_bits(gbc, 2); /* skip gainrng */
1066
        }
1067
    }
1068

1069
    /* bit allocation information */
1070
    if (s->bit_allocation_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
1071 1072 1073 1074 1075
        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)];
1076
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1077
            for (ch = !cpl_in_use; ch <= s->channels; ch++)
Justin Ruggles's avatar
Justin Ruggles committed
1078 1079
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
        } else if (!blk) {
1080 1081
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
                   "be present in block 0\n");
Justin Ruggles's avatar
Justin Ruggles committed
1082 1083
            return -1;
        }
1084
    }
1085

1086
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1087 1088
    if (!s->eac3 || !blk) {
        if (s->snr_offset_strategy && get_bits1(gbc)) {
Justin Ruggles's avatar
Justin Ruggles committed
1089 1090 1091 1092 1093 1094 1095 1096
            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 */
1097
                if (blk && s->snr_offset[ch] != snr) {
Justin Ruggles's avatar
Justin Ruggles committed
1098 1099 1100
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
                }
                s->snr_offset[ch] = snr;
1101 1102 1103 1104

                /* fast gain (normal AC-3 only) */
                if (!s->eac3) {
                    int prev = s->fast_gain[ch];
Justin Ruggles's avatar
Justin Ruggles committed
1105
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1106
                    /* run last 2 bit allocation stages if fast gain changes */
1107
                    if (blk && prev != s->fast_gain[ch])
1108 1109
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
                }
Justin Ruggles's avatar
Justin Ruggles committed
1110
            }
1111
        } else if (!s->eac3 && !blk) {
Justin Ruggles's avatar
Justin Ruggles committed
1112 1113
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
            return -1;
1114
        }
1115
    }
1116

1117 1118 1119 1120 1121 1122
    /* 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 */
1123
            if (blk && prev != s->fast_gain[ch])
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
                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
    }

1136
    /* coupling leak information */
1137
    if (cpl_in_use) {
1138 1139 1140 1141 1142
        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 */
1143 1144
            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
1145
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1146 1147 1148 1149
            }
            s->bit_alloc_params.cpl_fast_leak = fl;
            s->bit_alloc_params.cpl_slow_leak = sl;
        } else if (!s->eac3 && !blk) {
1150 1151
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
                   "be present in block 0\n");
Justin Ruggles's avatar
Justin Ruggles committed
1152 1153
            return -1;
        }
1154
        s->first_cpl_leak = 0;
1155
    }
1156

1157
    /* delta bit allocation information */
1158
    if (s->dba_syntax && get_bits1(gbc)) {
1159
        /* delta bit allocation exists (strategy) */
1160
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1161 1162 1163
            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");
1164 1165
                return -1;
            }
1166
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1167
        }
1168
        /* channel delta offset, len and bit allocation */
1169
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1170
            if (s->dba_mode[ch] == DBA_NEW) {
1171 1172
                s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
                for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1173 1174
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1175
                    s->dba_values[ch][seg]  = get_bits(gbc, 3);
1176
                }
1177 1178
                /* run last 2 bit allocation stages if new dba values */
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1179
            }
1180
        }
1181 1182
    } else if (blk == 0) {
        for (ch = 0; ch <= s->channels; ch++) {
1183
            s->dba_mode[ch] = DBA_NONE;
1184
        }
1185
    }
1186

1187
    /* Bit allocation */
1188 1189
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
        if (bit_alloc_stages[ch] > 2) {
1190
            /* Exponent mapping into PSD and PSD integration */
1191 1192 1193
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->psd[ch], s->band_psd[ch]);
1194
        }
1195
        if (bit_alloc_stages[ch] > 1) {
1196 1197
            /* Compute excitation function, Compute masking curve, and
               Apply delta bit allocation */
1198
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1199 1200 1201
                                           s->start_freq[ch],  s->end_freq[ch],
                                           s->fast_gain[ch],   (ch == s->lfe_ch),
                                           s->dba_mode[ch],    s->dba_nsegs[ch],
1202
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1203
                                           s->dba_values[ch],  s->mask[ch])) {
1204 1205 1206
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
                return -1;
            }
1207
        }
1208
        if (bit_alloc_stages[ch] > 0) {
1209
            /* Compute bit allocation */
1210 1211
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1212
            s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1213 1214 1215
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->snr_offset[ch],
                                      s->bit_alloc_params.floor,
1216
                                      bap_tab, s->bap[ch]);
1217
        }
1218
    }
1219

1220
    /* unused dummy data */
1221
    if (s->skip_syntax && get_bits1(gbc)) {
1222
        int skipl = get_bits(gbc, 9);
1223
        while (skipl--)
1224
            skip_bits(gbc, 8);
1225
    }
1226

1227
    /* unpack the transform coefficients
1228
       this also uncouples channels if coupling is in use. */
1229
    decode_transform_coeffs(s, blk);
1230

1231 1232
    /* TODO: generate enhanced coupling coordinates and uncouple */

1233
    /* recover coefficients if rematrixing is in use */
1234
    if (s->channel_mode == AC3_CHMODE_STEREO)
1235
        do_rematrixing(s);
1236

1237
    /* apply scaling to coefficients (headroom, dynrng) */
1238
    for (ch = 1; ch <= s->channels; ch++) {
1239
        float gain = s->mul_bias / 4194304.0f;
1240 1241
        if (s->channel_mode == AC3_CHMODE_DUALMONO) {
            gain *= s->dynamic_range[2 - ch];
1242
        } else {
1243
            gain *= s->dynamic_range[0];
1244
        }
1245 1246
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
                                               s->fixed_coeffs[ch], gain, 256);
1247
    }
1248

1249
    /* apply spectral extension to high frequency bins */
1250
    if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1251 1252 1253
        ff_eac3_apply_spectral_extension(s);
    }

1254 1255 1256 1257 1258 1259
    /* 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);
1260
    if (different_transforms) {
1261 1262
        /* the delay samples have already been downmixed, so we upmix the delay
           samples in order to reconstruct all channels before downmixing. */
1263
        if (s->downmixed) {
1264 1265 1266 1267 1268 1269
            s->downmixed = 0;
            ac3_upmix_delay(s);
        }

        do_imdct(s, s->channels);

1270 1271 1272
        if (downmix_output) {
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs,
                               s->out_channels, s->fbw_channels, 256);
1273 1274
        }
    } else {
1275 1276 1277
        if (downmix_output) {
            s->dsp.ac3_downmix(s->transform_coeffs + 1, s->downmix_coeffs,
                               s->out_channels, s->fbw_channels, 256);
1278 1279
        }

1280
        if (downmix_output && !s->downmixed) {
1281
            s->downmixed = 1;
1282 1283
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels,
                               s->fbw_channels, 128);
1284
        }
1285

1286
        do_imdct(s, s->out_channels);
1287 1288
    }

1289
    return 0;
1290 1291
}

1292 1293
/**
 * Decode a single AC-3 frame.
1294
 */
1295 1296
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
                            int *got_frame_ptr, AVPacket *avpkt)
1297
{
1298 1299
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
1300
    AC3DecodeContext *s = avctx->priv_data;
1301 1302 1303
    float   *out_samples_flt;
    int16_t *out_samples_s16;
    int blk, ch, err, ret;
1304
    const uint8_t *channel_map;
1305
    const float *output[AC3_MAX_CHANNELS];
1306

Justin Ruggles's avatar
Justin Ruggles committed
1307 1308
    /* copy input buffer to decoder context to avoid reading past the end
       of the buffer, which can be caused by a damaged input stream. */
1309 1310 1311 1312 1313
    if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
        // seems to be byte-swapped AC-3
        int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
        s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
    } else
1314
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1315 1316
    buf = s->input_buffer;
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
Justin Ruggles's avatar
Justin Ruggles committed
1317
    init_get_bits(&s->gbc, buf, buf_size * 8);
1318

1319
    /* parse the syncinfo */
1320
    err = parse_frame_header(s);
1321

1322
    if (err) {
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
        switch (err) {
        case AAC_AC3_PARSE_ERROR_SYNC:
            av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
            return -1;
        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) {
                av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "
                       "skipping frame\n");
                *got_frame_ptr = 0;
                return s->frame_size;
            } else {
                av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
            }
            break;
        default:
            av_log(avctx, AV_LOG_ERROR, "invalid header\n");
            break;
1351
        }
1352 1353 1354 1355 1356
    } 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;
1357
        } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1358
            /* check for crc mismatch */
1359 1360
            if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
                       s->frame_size - 2)) {
1361 1362 1363 1364
                av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
                err = AAC_AC3_PARSE_ERROR_CRC;
            }
        }
1365
    }
1366

1367 1368
    /* if frame is ok, set audio parameters */
    if (!err) {
Justin Ruggles's avatar
Justin Ruggles committed
1369
        avctx->sample_rate = s->sample_rate;
1370
        avctx->bit_rate    = s->bit_rate;
Justin Ruggles's avatar
Justin Ruggles committed
1371 1372 1373

        /* channel config */
        s->out_channels = s->channels;
1374 1375
        s->output_mode  = s->channel_mode;
        if (s->lfe_on)
1376
            s->output_mode |= AC3_OUTPUT_LFEON;
Justin Ruggles's avatar
Justin Ruggles committed
1377 1378 1379 1380
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
                avctx->request_channels < s->channels) {
            s->out_channels = avctx->request_channels;
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1381
            s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];
Justin Ruggles's avatar
Justin Ruggles committed
1382
        }
1383
        avctx->channels       = s->out_channels;
1384
        avctx->channel_layout = s->channel_layout;
1385

Justin Ruggles's avatar
Justin Ruggles committed
1386
        /* set downmixing coefficients if needed */
1387
        if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
Justin Ruggles's avatar
Justin Ruggles committed
1388 1389 1390
                s->fbw_channels == s->out_channels)) {
            set_downmix_coeffs(s);
        }
1391 1392
    } else if (!s->out_channels) {
        s->out_channels = avctx->channels;
1393
        if (s->out_channels < s->channels)
1394
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
Justin Ruggles's avatar
Justin Ruggles committed
1395
    }
1396 1397 1398 1399
    /* 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;
1400

1401 1402 1403 1404 1405 1406 1407 1408 1409
    /* get output buffer */
    s->frame.nb_samples = s->num_blocks * 256;
    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return ret;
    }
    out_samples_flt = (float   *)s->frame.data[0];
    out_samples_s16 = (int16_t *)s->frame.data[0];

1410
    /* decode the audio blocks */
1411
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1412 1413
    for (ch = 0; ch < s->out_channels; ch++)
        output[ch] = s->output[channel_map[ch]];
1414
    for (blk = 0; blk < s->num_blocks; blk++) {
1415 1416
        if (!err && decode_audio_block(s, blk)) {
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1417
            err = 1;
1418
        }
1419 1420 1421 1422 1423 1424 1425 1426 1427
        if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
            s->fmt_conv.float_interleave(out_samples_flt, output, 256,
                                         s->out_channels);
            out_samples_flt += 256 * s->out_channels;
        } else {
            s->fmt_conv.float_to_int16_interleave(out_samples_s16, output, 256,
                                                  s->out_channels);
            out_samples_s16 += 256 * s->out_channels;
        }
1428
    }
1429 1430 1431 1432

    *got_frame_ptr   = 1;
    *(AVFrame *)data = s->frame;

1433
    return FFMIN(buf_size, s->frame_size);
1434
}
1435

1436 1437
/**
 * Uninitialize the AC-3 decoder.
1438
 */
1439
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1440
{
1441
    AC3DecodeContext *s = avctx->priv_data;
1442 1443
    ff_mdct_end(&s->imdct_512);
    ff_mdct_end(&s->imdct_256);
1444

1445 1446 1447
    return 0;
}

1448 1449 1450
#define OFFSET(x) offsetof(AC3DecodeContext, x)
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
static const AVOption options[] = {
1451
    { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {1.0}, 0.0, 1.0, PAR },
1452 1453 1454 1455
    { NULL},
};

static const AVClass ac3_decoder_class = {
1456
    .class_name = "AC3 decoder",
1457 1458 1459 1460 1461
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

1462
AVCodec ff_ac3_decoder = {
1463 1464 1465
    .name           = "ac3",
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = CODEC_ID_AC3,
1466
    .priv_data_size = sizeof (AC3DecodeContext),
1467 1468 1469 1470 1471 1472 1473 1474 1475
    .init           = ac3_decode_init,
    .close          = ac3_decode_end,
    .decode         = ac3_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
    .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
                                                      AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_NONE },
    .priv_class     = &ac3_decoder_class,
1476 1477
};

1478
#if CONFIG_EAC3_DECODER
1479 1480 1481 1482 1483 1484
static const AVClass eac3_decoder_class = {
    .class_name = "E-AC3 decoder",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};
1485

1486
AVCodec ff_eac3_decoder = {
1487 1488 1489
    .name           = "eac3",
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = CODEC_ID_EAC3,
1490
    .priv_data_size = sizeof (AC3DecodeContext),
1491 1492 1493 1494 1495 1496 1497 1498 1499
    .init           = ac3_decode_init,
    .close          = ac3_decode_end,
    .decode         = ac3_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
    .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
                                                      AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_NONE },
    .priv_class     = &eac3_decoder_class,
1500
};
1501
#endif