ac3dec.c 47.5 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
 * Portions of this code are derived from liba52
11
 * http://liba52.sourceforge.net
12 13
 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
14
 *
15
 * This file is part of FFmpeg.
16
 *
17
 * FFmpeg is free software; you can redistribute it and/or
18
 * modify it under the terms of the GNU General Public
19 20 21
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
22
 * FFmpeg is distributed in the hope that it will be useful,
23 24
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
 * General Public License for more details.
26
 *
27
 * You should have received a copy of the GNU General Public
28
 * License along with FFmpeg; if not, write to the Free Software
29 30 31 32 33 34 35 36
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

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

37
#include "libavutil/crc.h"
38
#include "internal.h"
39
#include "aac_ac3_parser.h"
40
#include "ac3_parser.h"
41
#include "ac3dec.h"
42
#include "ac3dec_data.h"
43

44 45
/** Large enough for maximum possible frame size when the specification limit is ignored */
#define AC3_FRAME_BUFFER_SIZE 32768
46

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


54
/** tables for ungrouping mantissas */
55 56 57 58 59
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];
60

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

70
/** dynamic range table. converts codes to scale factors. */
71
static float dynamic_range_tab[256];
72

73
/** Adjustments in dB gain */
74 75 76
#define LEVEL_PLUS_3DB          1.4142135623730950
#define LEVEL_PLUS_1POINT5DB    1.1892071150027209
#define LEVEL_MINUS_1POINT5DB   0.8408964152537145
77 78 79
#define LEVEL_MINUS_3DB         0.7071067811865476
#define LEVEL_MINUS_4POINT5DB   0.5946035575013605
#define LEVEL_MINUS_6DB         0.5000000000000000
80
#define LEVEL_MINUS_9DB         0.3535533905932738
81
#define LEVEL_ZERO              0.0000000000000000
82 83
#define LEVEL_ONE               1.0000000000000000

84 85 86
static const float gain_levels[9] = {
    LEVEL_PLUS_3DB,
    LEVEL_PLUS_1POINT5DB,
87
    LEVEL_ONE,
88
    LEVEL_MINUS_1POINT5DB,
89 90 91
    LEVEL_MINUS_3DB,
    LEVEL_MINUS_4POINT5DB,
    LEVEL_MINUS_6DB,
92
    LEVEL_ZERO,
93 94
    LEVEL_MINUS_9DB
};
95

96 97 98 99 100 101 102 103 104 105 106 107
/**
 * Table for center mix levels
 * reference: Section 5.4.2.4 cmixlev
 */
static const uint8_t center_levels[4] = { 4, 5, 6, 5 };

/**
 * Table for surround mix levels
 * reference: Section 5.4.2.5 surmixlev
 */
static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };

108 109 110 111 112
/**
 * 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] = {
113 114 115 116 117 118 119 120
    { { 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 }, },
121
};
122

123 124 125 126 127
/**
 * Symmetrical Dequantization
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 *            Tables 7.19 to 7.23
 */
128
static inline int
129
symmetric_dequant(int code, int levels)
130
{
131
    return ((code - (levels >> 1)) << 24) / levels;
132 133
}

134 135 136
/*
 * Initialize tables at runtime.
 */
137
static av_cold void ac3_tables_init(void)
138
{
139
    int i;
140

141 142 143 144 145 146 147 148
    /* generate table for ungrouping 3 values in 7 bits
       reference: Section 7.1.3 Exponent Decoding */
    for(i=0; i<128; i++) {
        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;
    }

149 150 151 152
    /* generate grouped mantissa tables
       reference: Section 7.3.5 Ungrouping of Mantissas */
    for(i=0; i<32; i++) {
        /* bap=1 mantissas */
153 154 155
        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);
156 157 158
    }
    for(i=0; i<128; i++) {
        /* bap=2 mantissas */
159 160 161
        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);
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176

        /* 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 */
    for(i=0; i<7; i++) {
        /* bap=3 mantissas */
        b3_mantissas[i] = symmetric_dequant(i, 7);
    }
    for(i=0; i<15; i++) {
        /* bap=5 mantissas */
        b5_mantissas[i] = symmetric_dequant(i, 15);
    }
177

178 179 180 181
    /* generate dynamic range table
       reference: Section 7.7.1 Dynamic Range Control */
    for(i=0; i<256; i++) {
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
182
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
183
    }
184 185
}

186

187 188 189
/**
 * AVCodec initialization
 */
190
static av_cold int ac3_decode_init(AVCodecContext *avctx)
191
{
192 193
    AC3DecodeContext *s = avctx->priv_data;
    s->avctx = avctx;
194

195
    ac3_common_init();
196
    ac3_tables_init();
197 198
    ff_mdct_init(&s->imdct_256, 8, 1);
    ff_mdct_init(&s->imdct_512, 9, 1);
199
    ff_kbd_window_init(s->window, 5.0, 256);
200
    dsputil_init(&s->dsp, avctx);
201
    av_lfg_init(&s->dith_state, 0);
202

203
    /* set bias values for float to int16 conversion */
204
    if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
205 206
        s->add_bias = 385.0f;
        s->mul_bias = 1.0f;
207
    } else {
208 209
        s->add_bias = 0.0f;
        s->mul_bias = 32767.0f;
210 211
    }

212 213 214 215 216 217
    /* 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;
    }
218
    s->downmixed = 1;
219

220
    /* allocate context input buffer */
221
    if (avctx->error_recognition >= FF_ER_CAREFUL) {
222
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
223 224 225 226
        if (!s->input_buffer)
            return AVERROR_NOMEM;
    }

227
    avctx->sample_fmt = SAMPLE_FMT_S16;
228
    return 0;
229 230
}

231
/**
232
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
233
 * GetBitContext within AC3DecodeContext must point to
234
 * the start of the synchronized AC-3 bitstream.
235
 */
236
static int ac3_parse_header(AC3DecodeContext *s)
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
{
    GetBitContext *gbc = &s->gbc;
    int i;

    /* read the rest of the bsi. read twice for dual mono mode. */
    i = !(s->channel_mode);
    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);
        } while(i--);
    }

    return 0;
}

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

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

    /* get decoding parameters from header info */
286 287
    s->bit_alloc_params.sr_code     = hdr.sr_code;
    s->channel_mode                 = hdr.channel_mode;
288
    s->lfe_on                       = hdr.lfe_on;
289
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
290
    s->sample_rate                  = hdr.sample_rate;
291 292 293 294 295
    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;
296 297
    s->center_mix_level             = hdr.center_mix_level;
    s->surround_mix_level           = hdr.surround_mix_level;
298
    s->num_blocks                   = hdr.num_blocks;
299
    s->frame_type                   = hdr.frame_type;
300
    s->substreamid                  = hdr.substreamid;
301

302 303 304 305 306 307 308
    if(s->lfe_on) {
        s->start_freq[s->lfe_ch] = 0;
        s->end_freq[s->lfe_ch] = 7;
        s->num_exp_groups[s->lfe_ch] = 2;
        s->channel_in_cpl[s->lfe_ch] = 0;
    }

309 310 311 312 313 314 315 316 317 318 319
    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
320
        return ac3_parse_header(s);
321
    } else {
322 323
        s->eac3 = 1;
        return ff_eac3_parse_header(s);
324
    }
325 326 327 328 329 330 331 332 333
}

/**
 * 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;
334 335
    float cmix = gain_levels[center_levels[s->center_mix_level]];
    float smix = gain_levels[surround_levels[s->surround_mix_level]];
Loren Merritt's avatar
Loren Merritt committed
336
    float norm0, norm1;
337

338 339 340
    for(i=0; i<s->fbw_channels; i++) {
        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]];
341
    }
342
    if(s->channel_mode > 1 && s->channel_mode & 1) {
343
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
344
    }
345 346
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
        int nf = s->channel_mode - 2;
347
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
348
    }
349 350
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
        int nf = s->channel_mode - 4;
351
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
352
    }
353

Loren Merritt's avatar
Loren Merritt committed
354 355
    /* renormalize */
    norm0 = norm1 = 0.0;
356
    for(i=0; i<s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
357 358 359 360 361 362 363 364 365 366 367 368 369
        norm0 += s->downmix_coeffs[i][0];
        norm1 += s->downmix_coeffs[i][1];
    }
    norm0 = 1.0f / norm0;
    norm1 = 1.0f / norm1;
    for(i=0; i<s->fbw_channels; i++) {
        s->downmix_coeffs[i][0] *= norm0;
        s->downmix_coeffs[i][1] *= norm1;
    }

    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;
370
    }
371 372
}

373
/**
374 375
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
376
 */
377
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
378
                            uint8_t absexp, int8_t *dexps)
379
{
380
    int i, j, grp, group_size;
381 382 383 384
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
385
    group_size = exp_strategy + (exp_strategy == EXP_D45);
386
    for(grp=0,i=0; grp<ngrps; grp++) {
387
        expacc = get_bits(gbc, 7);
388 389 390
        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];
391
    }
392

393 394
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
395
    for(i=0,j=0; i<ngrps*3; i++) {
396
        prevexp += dexp[i] - 2;
397
        if (prevexp > 24U)
398
            return -1;
399 400 401 402 403
        switch (group_size) {
            case 4: dexps[j++] = prevexp;
                    dexps[j++] = prevexp;
            case 2: dexps[j++] = prevexp;
            case 1: dexps[j++] = prevexp;
404
        }
405
    }
406
    return 0;
407 408
}

409
/**
410
 * Generate transform coefficients for each coupled channel in the coupling
411 412 413
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
414
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
415 416 417 418
{
    int i, j, ch, bnd, subbnd;

    subbnd = -1;
419 420
    i = s->start_freq[CPL_CH];
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
421 422 423
        do {
            subbnd++;
            for(j=0; j<12; j++) {
424
                for(ch=1; ch<=s->fbw_channels; ch++) {
425
                    if(s->channel_in_cpl[ch]) {
426
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
427
                        if (ch == 2 && s->phase_flags[bnd])
428
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
429
                    }
430 431 432
                }
                i++;
            }
433
        } while(s->cpl_band_struct[subbnd]);
434 435 436
    }
}

437 438 439 440
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
typedef struct {
441 442 443
    int b1_mant[3];
    int b2_mant[3];
    int b4_mant[2];
444 445 446
    int b1ptr;
    int b2ptr;
    int b4ptr;
447 448
} mant_groups;

449
/**
450
 * Decode the transform coefficients for a particular channel
451 452
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
453
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
454
{
455
    GetBitContext *gbc = &s->gbc;
456
    int i, gcode, tbap, start, end;
457 458
    uint8_t *exps;
    uint8_t *bap;
459
    int *coeffs;
460

461 462
    exps = s->dexps[ch_index];
    bap = s->bap[ch_index];
463
    coeffs = s->fixed_coeffs[ch_index];
464 465
    start = s->start_freq[ch_index];
    end = s->end_freq[ch_index];
466

467
    for (i = start; i < end; i++) {
468 469
        tbap = bap[i];
        switch (tbap) {
470
            case 0:
471
                coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
472
                break;
473 474

            case 1:
475
                if(m->b1ptr > 2) {
476
                    gcode = get_bits(gbc, 5);
477 478 479 480
                    m->b1_mant[0] = b1_mantissas[gcode][0];
                    m->b1_mant[1] = b1_mantissas[gcode][1];
                    m->b1_mant[2] = b1_mantissas[gcode][2];
                    m->b1ptr = 0;
481
                }
482
                coeffs[i] = m->b1_mant[m->b1ptr++];
483
                break;
484 485

            case 2:
486
                if(m->b2ptr > 2) {
487
                    gcode = get_bits(gbc, 7);
488 489 490 491
                    m->b2_mant[0] = b2_mantissas[gcode][0];
                    m->b2_mant[1] = b2_mantissas[gcode][1];
                    m->b2_mant[2] = b2_mantissas[gcode][2];
                    m->b2ptr = 0;
492
                }
493
                coeffs[i] = m->b2_mant[m->b2ptr++];
494
                break;
495 496

            case 3:
497
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
498
                break;
499 500

            case 4:
501
                if(m->b4ptr > 1) {
502
                    gcode = get_bits(gbc, 7);
503 504 505
                    m->b4_mant[0] = b4_mantissas[gcode][0];
                    m->b4_mant[1] = b4_mantissas[gcode][1];
                    m->b4ptr = 0;
506
                }
507
                coeffs[i] = m->b4_mant[m->b4ptr++];
508
                break;
509 510

            case 5:
511
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
512
                break;
513

514
            default: {
515
                /* asymmetric dequantization */
516 517
                int qlevel = quantization_tab[tbap];
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
518
                break;
519
            }
520
        }
521
        coeffs[i] >>= exps[i];
522 523 524
    }
}

525
/**
526
 * Remove random dithering from coefficients with zero-bit mantissas
527 528
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
529
static void remove_dithering(AC3DecodeContext *s) {
530 531
    int ch, i;
    int end=0;
532
    int *coeffs;
533 534
    uint8_t *bap;

535 536
    for(ch=1; ch<=s->fbw_channels; ch++) {
        if(!s->dither_flag[ch]) {
537
            coeffs = s->fixed_coeffs[ch];
538 539 540
            bap = s->bap[ch];
            if(s->channel_in_cpl[ch])
                end = s->start_freq[CPL_CH];
541
            else
542
                end = s->end_freq[ch];
543
            for(i=0; i<end; i++) {
Justin Ruggles's avatar
Justin Ruggles committed
544
                if(!bap[i])
545
                    coeffs[i] = 0;
546
            }
547 548 549
            if(s->channel_in_cpl[ch]) {
                bap = s->bap[CPL_CH];
                for(; i<s->end_freq[CPL_CH]; i++) {
Justin Ruggles's avatar
Justin Ruggles committed
550
                    if(!bap[i])
551
                        coeffs[i] = 0;
552 553 554 555 556 557
                }
            }
        }
    }
}

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

575
/**
576
 * Decode the transform coefficients.
577
 */
578
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
579
{
580
    int ch, end;
581
    int got_cplchan = 0;
582 583
    mant_groups m;

584
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
585

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

606
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
607
    remove_dithering(s);
608 609
}

610
/**
611
 * Stereo rematrixing.
612 613
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
614
static void do_rematrixing(AC3DecodeContext *s)
615
{
616
    int bnd, i;
617
    int end, bndend;
618
    int tmp0, tmp1;
619

620
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
621

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

635 636 637 638 639
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
640
static inline void do_imdct(AC3DecodeContext *s, int channels)
641
{
Justin Ruggles's avatar
Justin Ruggles committed
642
    int ch;
643 644 645
    float add_bias = s->add_bias;
    if(s->out_channels==1 && channels>1)
        add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
646

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

666
/**
667
 * Downmix the output to mono or stereo.
668
 */
Loren Merritt's avatar
Loren Merritt committed
669
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
670 671
{
    int i, j;
672
    float v0, v1;
Loren Merritt's avatar
Loren Merritt committed
673 674
    if(out_ch == 2) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
675
            v0 = v1 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
676 677 678
            for(j=0; j<in_ch; j++) {
                v0 += samples[j][i] * matrix[j][0];
                v1 += samples[j][i] * matrix[j][1];
Loren Merritt's avatar
Loren Merritt committed
679 680 681
            }
            samples[0][i] = v0;
            samples[1][i] = v1;
682
        }
Loren Merritt's avatar
Loren Merritt committed
683 684
    } else if(out_ch == 1) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
685
            v0 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
686 687
            for(j=0; j<in_ch; j++)
                v0 += samples[j][i] * matrix[j][0];
Loren Merritt's avatar
Loren Merritt committed
688
            samples[0][i] = v0;
689 690 691 692
        }
    }
}

693 694 695 696 697
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
698
    int channel_data_size = sizeof(s->delay[0]);
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
    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;
    }
}

721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
/**
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
 * @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] band_struct decoded band structure
 * @param[out] num_subbands number of subbands (optionally NULL)
 * @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,
                                  uint8_t *band_struct, int *num_subbands,
739
                                  int *num_bands, uint8_t *band_sizes)
740
{
741
    int subbnd, bnd, n_subbands, n_bands=0;
742
    uint8_t bnd_sz[22];
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761

    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++) {
            band_struct[subbnd] = get_bits1(gbc);
        }
    } else if (!blk) {
        memcpy(band_struct,
               &default_band_struct[start_subband+1],
               n_subbands-1);
    }
    band_struct[n_subbands-1] = 0;

    /* 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 ) {
762
        n_bands = n_subbands;
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 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;
            if (band_struct[subbnd-1]) {
                n_bands--;
                bnd_sz[bnd] += subbnd_size;
            } else {
                bnd_sz[++bnd] = subbnd_size;
            }
        }
    }

    /* set optional output params */
    if (num_subbands)
        *num_subbands = n_subbands;
    if (num_bands)
        *num_bands = n_bands;
    if (band_sizes)
781
        memcpy(band_sizes, bnd_sz, n_bands);
782 783
}

784
/**
785
 * Decode a single audio block from the AC-3 bitstream.
786
 */
787
static int decode_audio_block(AC3DecodeContext *s, int blk)
788
{
789 790
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
791
    int i, bnd, seg, ch;
792 793
    int different_transforms;
    int downmix_output;
794
    int cpl_in_use;
795
    GetBitContext *gbc = &s->gbc;
796
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
797

798 799
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

800
    /* block switch flags */
801
    different_transforms = 0;
802
    if (s->block_switch_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
803 804 805 806 807
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->block_switch[ch] = get_bits1(gbc);
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
                different_transforms = 1;
        }
808
    }
809

810
    /* dithering flags */
811
    if (s->dither_flag_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
812 813 814
        for (ch = 1; ch <= fbw_channels; ch++) {
            s->dither_flag[ch] = get_bits1(gbc);
        }
815
    }
816

817
    /* dynamic range */
818
    i = !(s->channel_mode);
819
    do {
820
        if(get_bits1(gbc)) {
821
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
822
                                  s->avctx->drc_scale)+1.0;
823
        } else if(blk == 0) {
824
            s->dynamic_range[i] = 1.0f;
825
        }
826
    } while(i--);
827

828 829
    /* spectral extension strategy */
    if (s->eac3 && (!blk || get_bits1(gbc))) {
830
        if (get_bits1(gbc)) {
831
            ff_log_missing_feature(s->avctx, "Spectral extension", 1);
832
            return -1;
833
        }
834
        /* TODO: parse spectral extension strategy info */
835 836
    }

837
    /* TODO: spectral extension coordinates */
838

839
    /* coupling strategy */
840
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
841
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
842
        if (!s->eac3)
Justin Ruggles's avatar
Justin Ruggles committed
843
            s->cpl_in_use[blk] = get_bits1(gbc);
844
        if (s->cpl_in_use[blk]) {
845
            /* coupling in use */
846
            int cpl_start_subband, cpl_end_subband;
847

848 849 850 851 852
            if (channel_mode < AC3_CHMODE_STEREO) {
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
                return -1;
            }

853 854 855
            /* check for enhanced coupling */
            if (s->eac3 && get_bits1(gbc)) {
                /* TODO: parse enhanced coupling strategy info */
856
                ff_log_missing_feature(s->avctx, "Enhanced coupling", 1);
857 858 859
                return -1;
            }

860
            /* determine which channels are coupled */
861 862 863 864
            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
865 866
                for (ch = 1; ch <= fbw_channels; ch++)
                    s->channel_in_cpl[ch] = get_bits1(gbc);
867
            }
868

869
            /* phase flags in use */
870
            if (channel_mode == AC3_CHMODE_STEREO)
871
                s->phase_flags_in_use = get_bits1(gbc);
872

873
            /* coupling frequency range */
874
            /* TODO: modify coupling end freq if spectral extension is used */
875
            cpl_start_subband = get_bits(gbc, 4);
876
            cpl_end_subband   = get_bits(gbc, 4) + 3;
877 878 879 880
            s->num_cpl_subbands = cpl_end_subband - cpl_start_subband;
            if (s->num_cpl_subbands < 0) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d > %d)\n",
                       cpl_start_subband, cpl_end_subband);
881
                return -1;
882
            }
883
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
884
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
885

886 887 888 889 890
           decode_band_structure(gbc, blk, s->eac3, 0,
                                 cpl_start_subband, cpl_end_subband,
                                 ff_eac3_default_cpl_band_struct,
                                 s->cpl_band_struct, &s->num_cpl_subbands,
                                 &s->num_cpl_bands, NULL);
891
        } else {
892
            /* coupling not in use */
893
            for (ch = 1; ch <= fbw_channels; ch++) {
894
                s->channel_in_cpl[ch] = 0;
895 896
                s->first_cpl_coords[ch] = 1;
            }
897
            s->first_cpl_leak = s->eac3;
898
            s->phase_flags_in_use = 0;
899
        }
900 901
    } else if (!s->eac3) {
        if(!blk) {
Justin Ruggles's avatar
Justin Ruggles committed
902 903 904 905 906
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
            return -1;
        } else {
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
        }
907
    }
908
    cpl_in_use = s->cpl_in_use[blk];
909

910
    /* coupling coordinates */
911
    if (cpl_in_use) {
912
        int cpl_coords_exist = 0;
913

914
        for (ch = 1; ch <= fbw_channels; ch++) {
915
            if (s->channel_in_cpl[ch]) {
916
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
917
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
918
                    s->first_cpl_coords[ch] = 0;
919
                    cpl_coords_exist = 1;
920
                    master_cpl_coord = 3 * get_bits(gbc, 2);
921
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
922 923
                        cpl_coord_exp = get_bits(gbc, 4);
                        cpl_coord_mant = get_bits(gbc, 4);
924
                        if (cpl_coord_exp == 15)
925
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
926
                        else
927 928
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
929
                    }
930 931 932
                } else if (!blk) {
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
                    return -1;
933
                }
934 935 936
            } else {
                /* channel not in coupling */
                s->first_cpl_coords[ch] = 1;
937 938
            }
        }
939
        /* phase flags */
940
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
941
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
942
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
943 944
            }
        }
945
    }
946

947
    /* stereo rematrixing strategy and band structure */
948
    if (channel_mode == AC3_CHMODE_STEREO) {
949
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
950
            s->num_rematrixing_bands = 4;
951 952
            if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
953 954
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
                s->rematrixing_flags[bnd] = get_bits1(gbc);
955 956 957
        } else if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
            return -1;
958
        }
959 960
    }

961
    /* exponent strategies for each channel */
962
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
963
        if (!s->eac3)
964
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
965
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
966 967 968
            bit_alloc_stages[ch] = 3;
    }

969
    /* channel bandwidth */
970
    for (ch = 1; ch <= fbw_channels; ch++) {
971
        s->start_freq[ch] = 0;
972
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
973
            int group_size;
974 975 976
            int prev = s->end_freq[ch];
            if (s->channel_in_cpl[ch])
                s->end_freq[ch] = s->start_freq[CPL_CH];
977
            else {
978
                int bandwidth_code = get_bits(gbc, 6);
979
                if (bandwidth_code > 60) {
980
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
981 982
                    return -1;
                }
983
                s->end_freq[ch] = bandwidth_code * 3 + 73;
984
            }
985
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
986
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
987
            if(blk > 0 && s->end_freq[ch] != prev)
988
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
989
        }
990
    }
991
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
992
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
993
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
994
    }
995

996
    /* decode exponents for each channel */
997
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
998
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
999
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1000
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1001 1002
                                 s->num_exp_groups[ch], s->dexps[ch][0],
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1003 1004 1005
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
                return -1;
            }
1006
            if(ch != CPL_CH && ch != s->lfe_ch)
1007
                skip_bits(gbc, 2); /* skip gainrng */
1008
        }
1009
    }
1010

1011
    /* bit allocation information */
1012
    if (s->bit_allocation_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
1013 1014 1015 1016 1017
        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)];
1018
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
Justin Ruggles's avatar
Justin Ruggles committed
1019 1020 1021 1022 1023 1024
            for(ch=!cpl_in_use; ch<=s->channels; ch++)
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
        } else if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
            return -1;
        }
1025
    }
1026

1027
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1028 1029
    if(!s->eac3 || !blk){
        if(s->snr_offset_strategy && get_bits1(gbc)) {
Justin Ruggles's avatar
Justin Ruggles committed
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
            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 */
                if(blk && s->snr_offset[ch] != snr) {
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
                }
                s->snr_offset[ch] = snr;
1042 1043 1044 1045

                /* fast gain (normal AC-3 only) */
                if (!s->eac3) {
                    int prev = s->fast_gain[ch];
Justin Ruggles's avatar
Justin Ruggles committed
1046
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1047 1048 1049 1050
                    /* run last 2 bit allocation stages if fast gain changes */
                    if(blk && prev != s->fast_gain[ch])
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
                }
Justin Ruggles's avatar
Justin Ruggles committed
1051
            }
1052
        } else if (!s->eac3 && !blk) {
Justin Ruggles's avatar
Justin Ruggles committed
1053 1054
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
            return -1;
1055
        }
1056
    }
1057

1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
    /* 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 */
            if(blk && prev != s->fast_gain[ch])
                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
    }

1077
    /* coupling leak information */
1078
    if (cpl_in_use) {
1079 1080 1081 1082 1083 1084 1085
        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 */
            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
1086
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1087 1088 1089 1090
            }
            s->bit_alloc_params.cpl_fast_leak = fl;
            s->bit_alloc_params.cpl_slow_leak = sl;
        } else if (!s->eac3 && !blk) {
Justin Ruggles's avatar
Justin Ruggles committed
1091 1092 1093
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
            return -1;
        }
1094
        s->first_cpl_leak = 0;
1095
    }
1096

1097
    /* delta bit allocation information */
1098
    if (s->dba_syntax && get_bits1(gbc)) {
1099
        /* delta bit allocation exists (strategy) */
1100
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1101 1102 1103
            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");
1104 1105
                return -1;
            }
1106
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1107
        }
1108
        /* channel delta offset, len and bit allocation */
1109
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1110 1111 1112 1113 1114 1115
            if (s->dba_mode[ch] == DBA_NEW) {
                s->dba_nsegs[ch] = get_bits(gbc, 3);
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1116
                }
1117 1118
                /* run last 2 bit allocation stages if new dba values */
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1119
            }
1120
        }
1121
    } else if(blk == 0) {
1122 1123
        for(ch=0; ch<=s->channels; ch++) {
            s->dba_mode[ch] = DBA_NONE;
1124
        }
1125
    }
1126

1127
    /* Bit allocation */
1128
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1129 1130
        if(bit_alloc_stages[ch] > 2) {
            /* Exponent mapping into PSD and PSD integration */
1131 1132 1133
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->psd[ch], s->band_psd[ch]);
1134
        }
1135 1136 1137
        if(bit_alloc_stages[ch] > 1) {
            /* Compute excitation function, Compute masking curve, and
               Apply delta bit allocation */
1138
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1139 1140 1141 1142 1143
                                           s->start_freq[ch], s->end_freq[ch],
                                           s->fast_gain[ch], (ch == s->lfe_ch),
                                           s->dba_mode[ch], s->dba_nsegs[ch],
                                           s->dba_offsets[ch], s->dba_lengths[ch],
                                           s->dba_values[ch], s->mask[ch])) {
1144 1145 1146
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
                return -1;
            }
1147
        }
1148 1149
        if(bit_alloc_stages[ch] > 0) {
            /* Compute bit allocation */
1150 1151
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1152 1153 1154 1155
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->snr_offset[ch],
                                      s->bit_alloc_params.floor,
1156
                                      bap_tab, s->bap[ch]);
1157
        }
1158
    }
1159

1160
    /* unused dummy data */
1161
    if (s->skip_syntax && get_bits1(gbc)) {
1162
        int skipl = get_bits(gbc, 9);
1163
        while(skipl--)
1164
            skip_bits(gbc, 8);
1165
    }
1166

1167
    /* unpack the transform coefficients
1168
       this also uncouples channels if coupling is in use. */
1169
    decode_transform_coeffs(s, blk);
1170

1171 1172
    /* TODO: generate enhanced coupling coordinates and uncouple */

1173 1174
    /* TODO: apply spectral extension */

1175
    /* recover coefficients if rematrixing is in use */
1176 1177
    if(s->channel_mode == AC3_CHMODE_STEREO)
        do_rematrixing(s);
1178

1179
    /* apply scaling to coefficients (headroom, dynrng) */
1180
    for(ch=1; ch<=s->channels; ch++) {
1181
        float gain = s->mul_bias / 4194304.0f;
1182 1183
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
            gain *= s->dynamic_range[ch-1];
1184
        } else {
1185
            gain *= s->dynamic_range[0];
1186
        }
Loren Merritt's avatar
Loren Merritt committed
1187
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1188
    }
1189

1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
    /* 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);
    if(different_transforms) {
        /* the delay samples have already been downmixed, so we upmix the delay
           samples in order to reconstruct all channels before downmixing. */
        if(s->downmixed) {
            s->downmixed = 0;
            ac3_upmix_delay(s);
        }

        do_imdct(s, s->channels);

        if(downmix_output) {
Loren Merritt's avatar
Loren Merritt committed
1207
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1208 1209 1210
        }
    } else {
        if(downmix_output) {
Loren Merritt's avatar
Loren Merritt committed
1211
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1212 1213
        }

1214
        if(downmix_output && !s->downmixed) {
1215
            s->downmixed = 1;
Loren Merritt's avatar
Loren Merritt committed
1216
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1217
        }
1218

1219
        do_imdct(s, s->out_channels);
1220 1221
    }

1222
    return 0;
1223 1224
}

1225 1226
/**
 * Decode a single AC-3 frame.
1227
 */
1228 1229
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
                            const uint8_t *buf, int buf_size)
1230
{
1231
    AC3DecodeContext *s = avctx->priv_data;
1232
    int16_t *out_samples = (int16_t *)data;
1233
    int blk, ch, err;
1234

1235
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1236
    if (s->input_buffer) {
1237 1238
        /* copy input buffer to decoder context to avoid reading past the end
           of the buffer, which can be caused by a damaged input stream. */
1239
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1240 1241
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
    } else {
1242
        init_get_bits(&s->gbc, buf, buf_size * 8);
1243
    }
1244

1245
    /* parse the syncinfo */
1246
    *data_size = 0;
1247
    err = parse_frame_header(s);
1248 1249 1250 1251

    /* check that reported frame size fits in input buffer */
    if(s->frame_size > buf_size) {
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1252
        err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1253 1254 1255
    }

    /* check for crc mismatch */
1256
    if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
1257 1258
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1259
            err = AAC_AC3_PARSE_ERROR_CRC;
1260 1261 1262
        }
    }

1263
    if(err && err != AAC_AC3_PARSE_ERROR_CRC) {
1264
        switch(err) {
1265
            case AAC_AC3_PARSE_ERROR_SYNC:
1266
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1267
                return -1;
1268
            case AAC_AC3_PARSE_ERROR_BSID:
1269 1270
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
                break;
1271
            case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1272 1273
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
                break;
1274
            case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1275 1276
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
                break;
1277
            case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1278 1279 1280 1281 1282 1283
                /* 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");
                    return s->frame_size;
                } else {
Justin Ruggles's avatar
Justin Ruggles committed
1284
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1285
                }
1286
                break;
1287 1288 1289 1290
            default:
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
                break;
        }
1291
    }
1292

1293 1294
    /* if frame is ok, set audio parameters */
    if (!err) {
Justin Ruggles's avatar
Justin Ruggles committed
1295 1296 1297 1298 1299
        avctx->sample_rate = s->sample_rate;
        avctx->bit_rate = s->bit_rate;

        /* channel config */
        s->out_channels = s->channels;
1300 1301 1302
        s->output_mode = s->channel_mode;
        if(s->lfe_on)
            s->output_mode |= AC3_OUTPUT_LFEON;
Justin Ruggles's avatar
Justin Ruggles committed
1303 1304 1305 1306 1307 1308
        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;
        }
        avctx->channels = s->out_channels;
1309

Justin Ruggles's avatar
Justin Ruggles committed
1310 1311 1312 1313 1314
        /* set downmixing coefficients if needed */
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
                s->fbw_channels == s->out_channels)) {
            set_downmix_coeffs(s);
        }
1315 1316 1317 1318
    } else if (!s->out_channels) {
        s->out_channels = avctx->channels;
        if(s->out_channels < s->channels)
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
Justin Ruggles's avatar
Justin Ruggles committed
1319
    }
1320

1321
    /* decode the audio blocks */
1322
    for (blk = 0; blk < s->num_blocks; blk++) {
1323
        const float *output[s->out_channels];
1324 1325
        if (!err && decode_audio_block(s, blk)) {
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1326
            err = 1;
1327
        }
1328 1329 1330 1331
        for (ch = 0; ch < s->out_channels; ch++)
            output[ch] = s->output[ch];
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
        out_samples += 256 * s->out_channels;
1332
    }
1333
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1334
    return s->frame_size;
1335
}
1336

1337 1338
/**
 * Uninitialize the AC-3 decoder.
1339
 */
1340
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1341
{
1342
    AC3DecodeContext *s = avctx->priv_data;
1343 1344
    ff_mdct_end(&s->imdct_512);
    ff_mdct_end(&s->imdct_256);
1345

1346 1347
    av_freep(&s->input_buffer);

1348 1349 1350
    return 0;
}

1351
AVCodec ac3_decoder = {
1352 1353 1354 1355 1356 1357 1358
    .name = "ac3",
    .type = CODEC_TYPE_AUDIO,
    .id = CODEC_ID_AC3,
    .priv_data_size = sizeof (AC3DecodeContext),
    .init = ac3_decode_init,
    .close = ac3_decode_end,
    .decode = ac3_decode_frame,
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
};

AVCodec eac3_decoder = {
    .name = "eac3",
    .type = CODEC_TYPE_AUDIO,
    .id = CODEC_ID_EAC3,
    .priv_data_size = sizeof (AC3DecodeContext),
    .init = ac3_decode_init,
    .close = ac3_decode_end,
    .decode = ac3_decode_frame,
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1371
};