ac3dec.c 39.4 KB
Newer Older
1 2
/*
 * AC-3 Audio Decoder
3 4
 * This code is developed as part of Google Summer of Code 2006 Program.
 *
5
 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
6
 * Copyright (c) 2007 Justin Ruggles
7
 *
8
 * Portions of this code are derived from liba52
9
 * http://liba52.sourceforge.net
10 11
 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
12
 *
13
 * This file is part of FFmpeg.
14
 *
15
 * FFmpeg is free software; you can redistribute it and/or
16
 * modify it under the terms of the GNU General Public
17 18 19
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
20
 * FFmpeg is distributed in the hope that it will be useful,
21 22
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
 * General Public License for more details.
24
 *
25
 * You should have received a copy of the GNU General Public
26
 * License along with FFmpeg; if not, write to the Free Software
27 28 29 30 31 32 33 34
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

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

35 36
#include "libavutil/crc.h"
#include "libavutil/random.h"
37
#include "avcodec.h"
38
#include "ac3_parser.h"
39 40
#include "bitstream.h"
#include "dsputil.h"
41
#include "ac3dec.h"
42
#include "ac3dec_data.h"
43

44 45 46
/** Maximum possible frame size when the specification limit is ignored */
#define AC3_MAX_FRAME_SIZE 21695

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 201
    dsputil_init(&s->dsp, avctx);
    av_init_random(0, &s->dith_state);
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 221 222 223 224 225 226
    /* allocate context input buffer */
    if (avctx->error_resilience >= FF_ER_CAREFUL) {
        s->input_buffer = av_mallocz(AC3_MAX_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
        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
    if(hdr.bitstream_id > 10)
        return AC3_PARSE_ERROR_BSID;

312
    return ac3_parse_header(s);
313 314 315 316 317 318 319 320 321
}

/**
 * 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;
322 323
    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
324
    float norm0, norm1;
325

326 327 328
    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]];
329
    }
330
    if(s->channel_mode > 1 && s->channel_mode & 1) {
331
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
332
    }
333 334
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
        int nf = s->channel_mode - 2;
335
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
336
    }
337 338
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
        int nf = s->channel_mode - 4;
339
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
340
    }
341

Loren Merritt's avatar
Loren Merritt committed
342 343
    /* renormalize */
    norm0 = norm1 = 0.0;
344
    for(i=0; i<s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
345 346 347 348 349 350 351 352 353 354 355 356 357
        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;
358
    }
359 360
}

361
/**
362 363
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
364
 */
365
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
366
                             uint8_t absexp, int8_t *dexps)
367
{
368
    int i, j, grp, group_size;
369 370 371 372
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
373
    group_size = exp_strategy + (exp_strategy == EXP_D45);
374
    for(grp=0,i=0; grp<ngrps; grp++) {
375
        expacc = get_bits(gbc, 7);
376 377 378
        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];
379
    }
380

381 382 383 384
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
    for(i=0; i<ngrps*3; i++) {
        prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
385 386
        for(j=0; j<group_size; j++) {
            dexps[(i*group_size)+j] = prevexp;
387
        }
388 389 390
    }
}

391
/**
392
 * Generate transform coefficients for each coupled channel in the coupling
393 394 395
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
396
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
397 398 399 400
{
    int i, j, ch, bnd, subbnd;

    subbnd = -1;
401 402
    i = s->start_freq[CPL_CH];
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
403 404 405
        do {
            subbnd++;
            for(j=0; j<12; j++) {
406
                for(ch=1; ch<=s->fbw_channels; ch++) {
407
                    if(s->channel_in_cpl[ch]) {
408
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
409
                        if (ch == 2 && s->phase_flags[bnd])
410
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
411
                    }
412 413 414
                }
                i++;
            }
415
        } while(s->cpl_band_struct[subbnd]);
416 417 418
    }
}

419 420 421 422
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
typedef struct {
423 424 425
    int b1_mant[3];
    int b2_mant[3];
    int b4_mant[2];
426 427 428
    int b1ptr;
    int b2ptr;
    int b4ptr;
429 430
} mant_groups;

431 432 433 434
/**
 * Get the transform coefficients for a particular channel
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
435
static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
436
{
437
    GetBitContext *gbc = &s->gbc;
438
    int i, gcode, tbap, start, end;
439 440
    uint8_t *exps;
    uint8_t *bap;
441
    int *coeffs;
442

443 444
    exps = s->dexps[ch_index];
    bap = s->bap[ch_index];
445
    coeffs = s->fixed_coeffs[ch_index];
446 447
    start = s->start_freq[ch_index];
    end = s->end_freq[ch_index];
448

449
    for (i = start; i < end; i++) {
450 451
        tbap = bap[i];
        switch (tbap) {
452
            case 0:
453
                coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 0x400000;
454
                break;
455 456

            case 1:
457
                if(m->b1ptr > 2) {
458
                    gcode = get_bits(gbc, 5);
459 460 461 462
                    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;
463
                }
464
                coeffs[i] = m->b1_mant[m->b1ptr++];
465
                break;
466 467

            case 2:
468
                if(m->b2ptr > 2) {
469
                    gcode = get_bits(gbc, 7);
470 471 472 473
                    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;
474
                }
475
                coeffs[i] = m->b2_mant[m->b2ptr++];
476
                break;
477 478

            case 3:
479
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
480
                break;
481 482

            case 4:
483
                if(m->b4ptr > 1) {
484
                    gcode = get_bits(gbc, 7);
485 486 487
                    m->b4_mant[0] = b4_mantissas[gcode][0];
                    m->b4_mant[1] = b4_mantissas[gcode][1];
                    m->b4ptr = 0;
488
                }
489
                coeffs[i] = m->b4_mant[m->b4ptr++];
490
                break;
491 492

            case 5:
493
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
494
                break;
495

496
            default: {
497
                /* asymmetric dequantization */
498 499
                int qlevel = quantization_tab[tbap];
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
500
                break;
501
            }
502
        }
503
        coeffs[i] >>= exps[i];
504 505 506
    }
}

507
/**
508
 * Remove random dithering from coefficients with zero-bit mantissas
509 510
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
511
static void remove_dithering(AC3DecodeContext *s) {
512 513
    int ch, i;
    int end=0;
514
    int *coeffs;
515 516
    uint8_t *bap;

517 518
    for(ch=1; ch<=s->fbw_channels; ch++) {
        if(!s->dither_flag[ch]) {
519
            coeffs = s->fixed_coeffs[ch];
520 521 522
            bap = s->bap[ch];
            if(s->channel_in_cpl[ch])
                end = s->start_freq[CPL_CH];
523
            else
524
                end = s->end_freq[ch];
525
            for(i=0; i<end; i++) {
Justin Ruggles's avatar
Justin Ruggles committed
526
                if(!bap[i])
527
                    coeffs[i] = 0;
528
            }
529 530 531
            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
532
                    if(!bap[i])
533
                        coeffs[i] = 0;
534 535 536 537 538 539
                }
            }
        }
    }
}

540 541
/**
 * Get the transform coefficients.
542
 */
543
static void get_transform_coeffs(AC3DecodeContext *s)
544
{
545
    int ch, end;
546
    int got_cplchan = 0;
547 548
    mant_groups m;

549
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
550

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

571
    /* if any channel doesn't use dithering, zero appropriate coefficients */
572 573
    if(!s->dither_all)
        remove_dithering(s);
574 575
}

576
/**
577
 * Stereo rematrixing.
578 579
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
580
static void do_rematrixing(AC3DecodeContext *s)
581
{
582
    int bnd, i;
583
    int end, bndend;
584
    int tmp0, tmp1;
585

586
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
587

588 589
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
        if(s->rematrixing_flags[bnd]) {
590 591
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
592 593 594 595
                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;
596 597
            }
        }
598 599
    }
}
600

601 602 603 604 605
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
606
static inline void do_imdct(AC3DecodeContext *s, int channels)
607
{
Justin Ruggles's avatar
Justin Ruggles committed
608
    int ch;
609

610
    for (ch=1; ch<=channels; ch++) {
611
        if (s->block_switch[ch]) {
Loren Merritt's avatar
Loren Merritt committed
612 613 614 615 616
            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);
617
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, s->add_bias, 128);
Loren Merritt's avatar
Loren Merritt committed
618 619 620
            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);
621
        } else {
Loren Merritt's avatar
Loren Merritt committed
622
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
623
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, s->add_bias, 128);
Loren Merritt's avatar
Loren Merritt committed
624
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
625
        }
626 627 628
    }
}

629
/**
630
 * Downmix the output to mono or stereo.
631
 */
Loren Merritt's avatar
Loren Merritt committed
632 633
static av_noinline void ac3_downmix(AC3DecodeContext *s,
                                    float samples[AC3_MAX_CHANNELS][256])
634 635
{
    int i, j;
636
    float v0, v1;
637

Loren Merritt's avatar
Loren Merritt committed
638 639 640 641 642 643 644 645 646
    if(s->output_mode == AC3_CHMODE_STEREO) {
        for(i=0; i<256; i++) {
            v0 = v1 = 0.0f;
            for(j=0; j<s->fbw_channels; j++) {
                v0 += samples[j][i] * s->downmix_coeffs[j][0];
                v1 += samples[j][i] * s->downmix_coeffs[j][1];
            }
            samples[0][i] = v0;
            samples[1][i] = v1;
647
        }
Loren Merritt's avatar
Loren Merritt committed
648 649 650 651 652 653
    } else if(s->output_mode == AC3_CHMODE_MONO) {
        for(i=0; i<256; i++) {
            v0 = 0.0f;
            for(j=0; j<s->fbw_channels; j++)
                v0 += samples[j][i] * s->downmix_coeffs[j][0];
            samples[0][i] = v0;
654 655 656 657
        }
    }
}

658 659 660 661 662
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
Loren Merritt's avatar
Loren Merritt committed
663
    int channel_data_size = 128*sizeof(float);
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
    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;
    }
}

686
/**
687
 * Decode a single audio block from the AC-3 bitstream.
688
 */
689
static int decode_audio_block(AC3DecodeContext *s, int blk)
690
{
691 692
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
693
    int i, bnd, seg, ch;
694 695
    int different_transforms;
    int downmix_output;
696
    int cpl_in_use;
697
    GetBitContext *gbc = &s->gbc;
698
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
699

700 701
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

702
    /* block switch flags */
703 704
    different_transforms = 0;
    for (ch = 1; ch <= fbw_channels; ch++) {
705
        s->block_switch[ch] = get_bits1(gbc);
706 707 708
        if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
            different_transforms = 1;
    }
709

710
    /* dithering flags */
711
    s->dither_all = 1;
712
    for (ch = 1; ch <= fbw_channels; ch++) {
713 714 715
        s->dither_flag[ch] = get_bits1(gbc);
        if(!s->dither_flag[ch])
            s->dither_all = 0;
716
    }
717

718
    /* dynamic range */
719
    i = !(s->channel_mode);
720
    do {
721
        if(get_bits1(gbc)) {
722
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
723
                                  s->avctx->drc_scale)+1.0;
724
        } else if(blk == 0) {
725
            s->dynamic_range[i] = 1.0f;
726
        }
727
    } while(i--);
728

729
    /* coupling strategy */
730
    if (get_bits1(gbc)) {
731
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
732 733
        s->cpl_in_use[blk] = get_bits1(gbc);
        if (s->cpl_in_use[blk]) {
734
            /* coupling in use */
735
            int cpl_begin_freq, cpl_end_freq;
736

737 738 739 740 741
            if (channel_mode < AC3_CHMODE_STEREO) {
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
                return -1;
            }

742
            /* determine which channels are coupled */
743
            for (ch = 1; ch <= fbw_channels; ch++)
744
                s->channel_in_cpl[ch] = get_bits1(gbc);
745

746
            /* phase flags in use */
747
            if (channel_mode == AC3_CHMODE_STEREO)
748
                s->phase_flags_in_use = get_bits1(gbc);
749

750
            /* coupling frequency range and band structure */
751 752
            cpl_begin_freq = get_bits(gbc, 4);
            cpl_end_freq = get_bits(gbc, 4);
753
            if (3 + cpl_end_freq - cpl_begin_freq < 0) {
754
                av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
755
                return -1;
756
            }
757 758 759 760
            s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
            s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
            s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
            for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
761
                if (get_bits1(gbc)) {
762 763
                    s->cpl_band_struct[bnd] = 1;
                    s->num_cpl_bands--;
764
                }
765
            }
766
            s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
767
        } else {
768
            /* coupling not in use */
769
            for (ch = 1; ch <= fbw_channels; ch++)
770
                s->channel_in_cpl[ch] = 0;
771
        }
772 773 774
    } else if (!blk) {
        av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
        return -1;
775
    } else {
776
        s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
777
    }
778
    cpl_in_use = s->cpl_in_use[blk];
779

780
    /* coupling coordinates */
781
    if (cpl_in_use) {
782
        int cpl_coords_exist = 0;
783

784
        for (ch = 1; ch <= fbw_channels; ch++) {
785
            if (s->channel_in_cpl[ch]) {
786
                if (get_bits1(gbc)) {
787 788
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
                    cpl_coords_exist = 1;
789
                    master_cpl_coord = 3 * get_bits(gbc, 2);
790
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
791 792
                        cpl_coord_exp = get_bits(gbc, 4);
                        cpl_coord_mant = get_bits(gbc, 4);
793
                        if (cpl_coord_exp == 15)
794
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
795
                        else
796 797
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
798
                    }
799 800 801
                } else if (!blk) {
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
                    return -1;
802
                }
803 804
            }
        }
805
        /* phase flags */
806
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
807
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
808
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
809 810
            }
        }
811
    }
812

813
    /* stereo rematrixing strategy and band structure */
814
    if (channel_mode == AC3_CHMODE_STEREO) {
815
        if (get_bits1(gbc)) {
816
            s->num_rematrixing_bands = 4;
817
            if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
818 819 820
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
                s->rematrixing_flags[bnd] = get_bits1(gbc);
821 822 823
        } else if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
            return -1;
824
        }
825 826
    }

827
    /* exponent strategies for each channel */
828 829
    s->exp_strategy[blk][CPL_CH] = EXP_REUSE;
    s->exp_strategy[blk][s->lfe_ch] = EXP_REUSE;
830
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
831 832
        s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
833 834 835
            bit_alloc_stages[ch] = 3;
    }

836
    /* channel bandwidth */
837
    for (ch = 1; ch <= fbw_channels; ch++) {
838
        s->start_freq[ch] = 0;
839
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
840
            int group_size;
841 842 843
            int prev = s->end_freq[ch];
            if (s->channel_in_cpl[ch])
                s->end_freq[ch] = s->start_freq[CPL_CH];
844
            else {
845
                int bandwidth_code = get_bits(gbc, 6);
846
                if (bandwidth_code > 60) {
847
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
848 849
                    return -1;
                }
850
                s->end_freq[ch] = bandwidth_code * 3 + 73;
851
            }
852
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
853
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
854
            if(blk > 0 && s->end_freq[ch] != prev)
855
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
856
        }
857
    }
858
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
859
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
860
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
861
    }
862

863
    /* decode exponents for each channel */
864
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
865
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
866
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
867
            decode_exponents(gbc, s->exp_strategy[blk][ch],
868
                             s->num_exp_groups[ch], s->dexps[ch][0],
869 870
                             &s->dexps[ch][s->start_freq[ch]+!!ch]);
            if(ch != CPL_CH && ch != s->lfe_ch)
871
                skip_bits(gbc, 2); /* skip gainrng */
872
        }
873
    }
874

875
    /* bit allocation information */
876
    if (get_bits1(gbc)) {
877 878 879 880 881
        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)];
        s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
882
        for(ch=!cpl_in_use; ch<=s->channels; ch++)
883
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
884 885 886
    } else if (!blk) {
        av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
        return -1;
887
    }
888

889
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
890
    if (get_bits1(gbc)) {
891
        int csnr;
892
        csnr = (get_bits(gbc, 6) - 15) << 4;
893
        for (ch = !cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
894 895
            s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
896
        }
897
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
898 899 900
    } else if (!blk) {
        av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
        return -1;
901
    }
902

903
    /* coupling leak information */
904
    if (cpl_in_use) {
905
        if (get_bits1(gbc)) {
Justin Ruggles's avatar
Justin Ruggles committed
906 907 908 909 910 911 912
            s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
            s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
            bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
        } else if (!blk) {
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
            return -1;
        }
913
    }
914

915
    /* delta bit allocation information */
916
    if (get_bits1(gbc)) {
917
        /* delta bit allocation exists (strategy) */
918
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
919 920 921
            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");
922 923
                return -1;
            }
924
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
925
        }
926
        /* channel delta offset, len and bit allocation */
927
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
928 929 930 931 932 933
            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);
934
                }
935 936
                /* run last 2 bit allocation stages if new dba values */
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
937
            }
938
        }
939
    } else if(blk == 0) {
940 941
        for(ch=0; ch<=s->channels; ch++) {
            s->dba_mode[ch] = DBA_NONE;
942
        }
943
    }
944

945
    /* Bit allocation */
946
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
947 948
        if(bit_alloc_stages[ch] > 2) {
            /* Exponent mapping into PSD and PSD integration */
949 950 951
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
                                      s->start_freq[ch], s->end_freq[ch],
                                      s->psd[ch], s->band_psd[ch]);
952
        }
953 954 955
        if(bit_alloc_stages[ch] > 1) {
            /* Compute excitation function, Compute masking curve, and
               Apply delta bit allocation */
956 957 958 959 960 961
            ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
                                       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]);
962
        }
963 964
        if(bit_alloc_stages[ch] > 0) {
            /* Compute bit allocation */
965 966 967 968
            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,
969
                                      ff_ac3_bap_tab, s->bap[ch]);
970
        }
971
    }
972

973
    /* unused dummy data */
974 975
    if (get_bits1(gbc)) {
        int skipl = get_bits(gbc, 9);
976
        while(skipl--)
977
            skip_bits(gbc, 8);
978
    }
979

980
    /* unpack the transform coefficients
981
       this also uncouples channels if coupling is in use. */
982
    get_transform_coeffs(s);
983

984
    /* recover coefficients if rematrixing is in use */
985 986
    if(s->channel_mode == AC3_CHMODE_STEREO)
        do_rematrixing(s);
987

988
    /* apply scaling to coefficients (headroom, dynrng) */
989
    for(ch=1; ch<=s->channels; ch++) {
990
        float gain = s->mul_bias / 4194304.0f;
991 992
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
            gain *= s->dynamic_range[ch-1];
993
        } else {
994
            gain *= s->dynamic_range[0];
995
        }
996 997
        for(i=0; i<256; i++) {
            s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
998 999
        }
    }
1000

1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
    /* 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
1018
            ac3_downmix(s, s->output);
1019 1020 1021
        }
    } else {
        if(downmix_output) {
Loren Merritt's avatar
Loren Merritt committed
1022
            ac3_downmix(s, s->transform_coeffs+1);
1023 1024 1025 1026
        }

        if(!s->downmixed) {
            s->downmixed = 1;
Loren Merritt's avatar
Loren Merritt committed
1027
            // FIXME delay[] is half the size of the other downmixes
Loren Merritt's avatar
Loren Merritt committed
1028
            ac3_downmix(s, s->delay);
1029
        }
1030

1031
        do_imdct(s, s->out_channels);
1032 1033
    }

1034
    return 0;
1035 1036
}

1037 1038
/**
 * Decode a single AC-3 frame.
1039
 */
1040 1041
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
                            const uint8_t *buf, int buf_size)
1042
{
1043
    AC3DecodeContext *s = avctx->priv_data;
1044
    int16_t *out_samples = (int16_t *)data;
1045
    int blk, ch, err;
1046

1047
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1048
    if (s->input_buffer) {
1049 1050 1051 1052 1053
        /* copy input buffer to decoder context to avoid reading past the end
           of the buffer, which can be caused by a damaged input stream. */
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
    } else {
1054
        init_get_bits(&s->gbc, buf, buf_size * 8);
1055
    }
1056

1057
    /* parse the syncinfo */
1058
    *data_size = 0;
1059
    err = parse_frame_header(s);
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070

    /* 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 = AC3_PARSE_ERROR_FRAME_SIZE;
    }

    /* check for crc mismatch */
    if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
        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");
1071
            err = AC3_PARSE_ERROR_CRC;
1072 1073 1074
        }
    }

1075
    if(err && err != AC3_PARSE_ERROR_CRC) {
1076 1077
        switch(err) {
            case AC3_PARSE_ERROR_SYNC:
1078
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1079
                return -1;
1080 1081 1082 1083 1084 1085 1086 1087 1088
            case AC3_PARSE_ERROR_BSID:
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
                break;
            case AC3_PARSE_ERROR_SAMPLE_RATE:
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
                break;
            case AC3_PARSE_ERROR_FRAME_SIZE:
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
                break;
1089
            case AC3_PARSE_ERROR_FRAME_TYPE:
1090 1091 1092 1093 1094 1095
                /* 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
1096
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1097
                }
1098
                break;
1099 1100 1101 1102
            default:
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
                break;
        }
1103
    }
1104

1105 1106
    /* if frame is ok, set audio parameters */
    if (!err) {
Justin Ruggles's avatar
Justin Ruggles committed
1107 1108 1109 1110 1111
        avctx->sample_rate = s->sample_rate;
        avctx->bit_rate = s->bit_rate;

        /* channel config */
        s->out_channels = s->channels;
1112 1113 1114
        s->output_mode = s->channel_mode;
        if(s->lfe_on)
            s->output_mode |= AC3_OUTPUT_LFEON;
Justin Ruggles's avatar
Justin Ruggles committed
1115 1116 1117 1118 1119 1120
        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;
1121

Justin Ruggles's avatar
Justin Ruggles committed
1122 1123 1124 1125 1126
        /* 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);
        }
1127 1128 1129 1130
    } 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
1131
    }
1132

1133
    /* decode the audio blocks */
1134
    for (blk = 0; blk < s->num_blocks; blk++) {
1135
        const float *output[s->out_channels];
1136 1137
        if (!err && decode_audio_block(s, blk)) {
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1138
        }
1139 1140 1141 1142
        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;
1143
    }
1144
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1145
    return s->frame_size;
1146
}
1147

1148 1149
/**
 * Uninitialize the AC-3 decoder.
1150
 */
1151
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1152
{
1153
    AC3DecodeContext *s = avctx->priv_data;
1154 1155
    ff_mdct_end(&s->imdct_512);
    ff_mdct_end(&s->imdct_256);
1156

1157 1158
    av_freep(&s->input_buffer);

1159 1160 1161
    return 0;
}

1162
AVCodec ac3_decoder = {
1163 1164 1165 1166 1167 1168 1169
    .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,
1170
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 / AC-3"),
1171
};