Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ e25973a1

History | View | Annotate | Download (43.7 KB)

1
/*
2
 * AC-3 Audio Decoder
3
 * This code is developed as part of Google Summer of Code 2006 Program.
4
 *
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
 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
11
 * 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
 * License as published by the Free Software Foundation; either
18
 * version 2 of the License, or (at your option) any later version.
19
 *
20
 * FFmpeg is distributed in the hope that it will be useful,
21
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22
 * 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
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28
 */
29

    
30
#include <stdio.h>
31
#include <stddef.h>
32
#include <math.h>
33
#include <string.h>
34

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

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

    
45
/**
46
 * Table of bin locations for rematrixing bands
47
 * reference: Section 7.5.2 Rematrixing : Frequency Band Definitions
48
 */
49
static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 };
50

    
51
/** table for grouping exponents */
52
static uint8_t exp_ungroup_tab[128][3];
53

    
54

    
55
/** tables for ungrouping mantissas */
56
static int b1_mantissas[32][3];
57
static int b2_mantissas[128][3];
58
static int b3_mantissas[8];
59
static int b4_mantissas[128][2];
60
static int b5_mantissas[16];
61

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

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

    
74
/** Adjustments in dB gain */
75
#define LEVEL_MINUS_3DB         0.7071067811865476
76
#define LEVEL_MINUS_4POINT5DB   0.5946035575013605
77
#define LEVEL_MINUS_6DB         0.5000000000000000
78
#define LEVEL_MINUS_9DB         0.3535533905932738
79
#define LEVEL_ZERO              0.0000000000000000
80
#define LEVEL_ONE               1.0000000000000000
81

    
82
static const float gain_levels[6] = {
83
    LEVEL_ZERO,
84
    LEVEL_ONE,
85
    LEVEL_MINUS_3DB,
86
    LEVEL_MINUS_4POINT5DB,
87
    LEVEL_MINUS_6DB,
88
    LEVEL_MINUS_9DB
89
};
90

    
91
/**
92
 * Table for default stereo downmixing coefficients
93
 * reference: Section 7.8.2 Downmixing Into Two Channels
94
 */
95
static const uint8_t ac3_default_coeffs[8][5][2] = {
96
    { { 1, 0 }, { 0, 1 },                               },
97
    { { 2, 2 },                                         },
98
    { { 1, 0 }, { 0, 1 },                               },
99
    { { 1, 0 }, { 3, 3 }, { 0, 1 },                     },
100
    { { 1, 0 }, { 0, 1 }, { 4, 4 },                     },
101
    { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 },           },
102
    { { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 },           },
103
    { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, },
104
};
105

    
106
/* override ac3.h to include coupling channel */
107
#undef AC3_MAX_CHANNELS
108
#define AC3_MAX_CHANNELS 7
109
#define CPL_CH 0
110

    
111
#define AC3_OUTPUT_LFEON  8
112

    
113
typedef struct {
114
    int channel_mode;                       ///< channel mode (acmod)
115
    int block_switch[AC3_MAX_CHANNELS];     ///< block switch flags
116
    int dither_flag[AC3_MAX_CHANNELS];      ///< dither flags
117
    int dither_all;                         ///< true if all channels are dithered
118
    int cpl_in_use;                         ///< coupling in use
119
    int channel_in_cpl[AC3_MAX_CHANNELS];   ///< channel in coupling
120
    int phase_flags_in_use;                 ///< phase flags in use
121
    int phase_flags[18];                    ///< phase flags
122
    int cpl_band_struct[18];                ///< coupling band structure
123
    int num_rematrixing_bands;              ///< number of rematrixing bands
124
    int rematrixing_flags[4];               ///< rematrixing flags
125
    int exp_strategy[AC3_MAX_CHANNELS];     ///< exponent strategies
126
    int snr_offset[AC3_MAX_CHANNELS];       ///< signal-to-noise ratio offsets
127
    int fast_gain[AC3_MAX_CHANNELS];        ///< fast gain values (signal-to-mask ratio)
128
    int dba_mode[AC3_MAX_CHANNELS];         ///< delta bit allocation mode
129
    int dba_nsegs[AC3_MAX_CHANNELS];        ///< number of delta segments
130
    uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets
131
    uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths
132
    uint8_t dba_values[AC3_MAX_CHANNELS][8];  ///< delta values for each segment
133

    
134
    int sample_rate;                        ///< sample frequency, in Hz
135
    int bit_rate;                           ///< stream bit rate, in bits-per-second
136
    int frame_size;                         ///< current frame size, in bytes
137

    
138
    int channels;                           ///< number of total channels
139
    int fbw_channels;                       ///< number of full-bandwidth channels
140
    int lfe_on;                             ///< lfe channel in use
141
    int lfe_ch;                             ///< index of LFE channel
142
    int output_mode;                        ///< output channel configuration
143
    int out_channels;                       ///< number of output channels
144

    
145
    int center_mix_level;                   ///< Center mix level index
146
    int surround_mix_level;                 ///< Surround mix level index
147
    float downmix_coeffs[AC3_MAX_CHANNELS][2];  ///< stereo downmix coefficients
148
    float downmix_coeff_adjust[2];          ///< adjustment needed for each output channel when downmixing
149
    float dynamic_range[2];                 ///< dynamic range
150
    int   cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates
151
    int   num_cpl_bands;                    ///< number of coupling bands
152
    int   num_cpl_subbands;                 ///< number of coupling sub bands
153
    int   start_freq[AC3_MAX_CHANNELS];     ///< start frequency bin
154
    int   end_freq[AC3_MAX_CHANNELS];       ///< end frequency bin
155
    AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters
156

    
157
    int8_t  dexps[AC3_MAX_CHANNELS][256];   ///< decoded exponents
158
    uint8_t bap[AC3_MAX_CHANNELS][256];     ///< bit allocation pointers
159
    int16_t psd[AC3_MAX_CHANNELS][256];     ///< scaled exponents
160
    int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents
161
    int16_t mask[AC3_MAX_CHANNELS][50];     ///< masking curve values
162

    
163
    int fixed_coeffs[AC3_MAX_CHANNELS][256];    ///> fixed-point transform coefficients
164
    DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]);  ///< transform coefficients
165
    int downmixed;                              ///< indicates if coeffs are currently downmixed
166

    
167
    /* For IMDCT. */
168
    MDCTContext imdct_512;                  ///< for 512 sample IMDCT
169
    MDCTContext imdct_256;                  ///< for 256 sample IMDCT
170
    DSPContext  dsp;                        ///< for optimization
171
    float       add_bias;                   ///< offset for float_to_int16 conversion
172
    float       mul_bias;                   ///< scaling for float_to_int16 conversion
173

    
174
    DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][256]);       ///< output after imdct transform and windowing
175
    DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][256]); ///< final 16-bit integer output
176
    DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][256]);        ///< delay - added to the next block
177
    DECLARE_ALIGNED_16(float, tmp_imdct[256]);                      ///< temporary storage for imdct transform
178
    DECLARE_ALIGNED_16(float, tmp_output[512]);                     ///< temporary storage for output before windowing
179
    DECLARE_ALIGNED_16(float, window[256]);                         ///< window coefficients
180

    
181
    /* Miscellaneous. */
182
    GetBitContext gbc;                      ///< bitstream reader
183
    AVRandomState dith_state;               ///< for dither generation
184
    AVCodecContext *avctx;                  ///< parent context
185
    uint8_t *input_buffer;                  ///< temp buffer to prevent overread
186
} AC3DecodeContext;
187

    
188
/**
189
 * Symmetrical Dequantization
190
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
191
 *            Tables 7.19 to 7.23
192
 */
193
static inline int
194
symmetric_dequant(int code, int levels)
195
{
196
    return ((code - (levels >> 1)) << 24) / levels;
197
}
198

    
199
/*
200
 * Initialize tables at runtime.
201
 */
202
static av_cold void ac3_tables_init(void)
203
{
204
    int i;
205

    
206
    /* generate grouped mantissa tables
207
       reference: Section 7.3.5 Ungrouping of Mantissas */
208
    for(i=0; i<32; i++) {
209
        /* bap=1 mantissas */
210
        b1_mantissas[i][0] = symmetric_dequant( i / 9     , 3);
211
        b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3);
212
        b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3);
213
    }
214
    for(i=0; i<128; i++) {
215
        /* bap=2 mantissas */
216
        b2_mantissas[i][0] = symmetric_dequant( i / 25     , 5);
217
        b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5);
218
        b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5);
219

    
220
        /* bap=4 mantissas */
221
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
222
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
223
    }
224
    /* generate ungrouped mantissa tables
225
       reference: Tables 7.21 and 7.23 */
226
    for(i=0; i<7; i++) {
227
        /* bap=3 mantissas */
228
        b3_mantissas[i] = symmetric_dequant(i, 7);
229
    }
230
    for(i=0; i<15; i++) {
231
        /* bap=5 mantissas */
232
        b5_mantissas[i] = symmetric_dequant(i, 15);
233
    }
234

    
235
    /* generate dynamic range table
236
       reference: Section 7.7.1 Dynamic Range Control */
237
    for(i=0; i<256; i++) {
238
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
239
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
240
    }
241

    
242
    /* generate exponent tables
243
       reference: Section 7.1.3 Exponent Decoding */
244
    for(i=0; i<128; i++) {
245
        exp_ungroup_tab[i][0] =  i / 25;
246
        exp_ungroup_tab[i][1] = (i % 25) / 5;
247
        exp_ungroup_tab[i][2] = (i % 25) % 5;
248
    }
249
}
250

    
251

    
252
/**
253
 * AVCodec initialization
254
 */
255
static av_cold int ac3_decode_init(AVCodecContext *avctx)
256
{
257
    AC3DecodeContext *s = avctx->priv_data;
258
    s->avctx = avctx;
259

    
260
    ac3_common_init();
261
    ac3_tables_init();
262
    ff_mdct_init(&s->imdct_256, 8, 1);
263
    ff_mdct_init(&s->imdct_512, 9, 1);
264
    ff_kbd_window_init(s->window, 5.0, 256);
265
    dsputil_init(&s->dsp, avctx);
266
    av_init_random(0, &s->dith_state);
267

    
268
    /* set bias values for float to int16 conversion */
269
    if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
270
        s->add_bias = 385.0f;
271
        s->mul_bias = 1.0f;
272
    } else {
273
        s->add_bias = 0.0f;
274
        s->mul_bias = 32767.0f;
275
    }
276

    
277
    /* allow downmixing to stereo or mono */
278
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
279
            avctx->request_channels < avctx->channels &&
280
            avctx->request_channels <= 2) {
281
        avctx->channels = avctx->request_channels;
282
    }
283
    s->downmixed = 1;
284

    
285
    /* allocate context input buffer */
286
    if (avctx->error_resilience >= FF_ER_CAREFUL) {
287
        s->input_buffer = av_mallocz(AC3_MAX_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
288
        if (!s->input_buffer)
289
            return AVERROR_NOMEM;
290
    }
291

    
292
    return 0;
293
}
294

    
295
/**
296
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
297
 * GetBitContext within AC3DecodeContext must point to
298
 * start of the synchronized ac3 bitstream.
299
 */
300
static int ac3_parse_header(AC3DecodeContext *s)
301
{
302
    AC3HeaderInfo hdr;
303
    GetBitContext *gbc = &s->gbc;
304
    int err, i;
305

    
306
    err = ff_ac3_parse_header(gbc, &hdr);
307
    if(err)
308
        return err;
309

    
310
    if(hdr.bitstream_id > 10)
311
        return AC3_PARSE_ERROR_BSID;
312

    
313
    /* get decoding parameters from header info */
314
    s->bit_alloc_params.sr_code     = hdr.sr_code;
315
    s->channel_mode                 = hdr.channel_mode;
316
    s->lfe_on                       = hdr.lfe_on;
317
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
318
    s->sample_rate                  = hdr.sample_rate;
319
    s->bit_rate                     = hdr.bit_rate;
320
    s->channels                     = hdr.channels;
321
    s->fbw_channels                 = s->channels - s->lfe_on;
322
    s->lfe_ch                       = s->fbw_channels + 1;
323
    s->frame_size                   = hdr.frame_size;
324
    s->center_mix_level             = hdr.center_mix_level;
325
    s->surround_mix_level           = hdr.surround_mix_level;
326

    
327
    /* read the rest of the bsi. read twice for dual mono mode. */
328
    i = !(s->channel_mode);
329
    do {
330
        skip_bits(gbc, 5); // skip dialog normalization
331
        if (get_bits1(gbc))
332
            skip_bits(gbc, 8); //skip compression
333
        if (get_bits1(gbc))
334
            skip_bits(gbc, 8); //skip language code
335
        if (get_bits1(gbc))
336
            skip_bits(gbc, 7); //skip audio production information
337
    } while (i--);
338

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

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

    
348
    /* skip additional bitstream info */
349
    if (get_bits1(gbc)) {
350
        i = get_bits(gbc, 6);
351
        do {
352
            skip_bits(gbc, 8);
353
        } while(i--);
354
    }
355

    
356
    return 0;
357
}
358

    
359
/**
360
 * Set stereo downmixing coefficients based on frame header info.
361
 * reference: Section 7.8.2 Downmixing Into Two Channels
362
 */
363
static void set_downmix_coeffs(AC3DecodeContext *s)
364
{
365
    int i;
366
    float cmix = gain_levels[s->center_mix_level];
367
    float smix = gain_levels[s->surround_mix_level];
368

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

    
385
    /* calculate adjustment needed for each channel to avoid clipping */
386
    s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
387
    for(i=0; i<s->fbw_channels; i++) {
388
        s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
389
        s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
390
    }
391
    s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
392
    s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
393
}
394

    
395
/**
396
 * Decode the grouped exponents according to exponent strategy.
397
 * reference: Section 7.1.3 Exponent Decoding
398
 */
399
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
400
                             uint8_t absexp, int8_t *dexps)
401
{
402
    int i, j, grp, group_size;
403
    int dexp[256];
404
    int expacc, prevexp;
405

    
406
    /* unpack groups */
407
    group_size = exp_strategy + (exp_strategy == EXP_D45);
408
    for(grp=0,i=0; grp<ngrps; grp++) {
409
        expacc = get_bits(gbc, 7);
410
        dexp[i++] = exp_ungroup_tab[expacc][0];
411
        dexp[i++] = exp_ungroup_tab[expacc][1];
412
        dexp[i++] = exp_ungroup_tab[expacc][2];
413
    }
414

    
415
    /* convert to absolute exps and expand groups */
416
    prevexp = absexp;
417
    for(i=0; i<ngrps*3; i++) {
418
        prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
419
        for(j=0; j<group_size; j++) {
420
            dexps[(i*group_size)+j] = prevexp;
421
        }
422
    }
423
}
424

    
425
/**
426
 * Generate transform coefficients for each coupled channel in the coupling
427
 * range using the coupling coefficients and coupling coordinates.
428
 * reference: Section 7.4.3 Coupling Coordinate Format
429
 */
430
static void uncouple_channels(AC3DecodeContext *s)
431
{
432
    int i, j, ch, bnd, subbnd;
433

    
434
    subbnd = -1;
435
    i = s->start_freq[CPL_CH];
436
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
437
        do {
438
            subbnd++;
439
            for(j=0; j<12; j++) {
440
                for(ch=1; ch<=s->fbw_channels; ch++) {
441
                    if(s->channel_in_cpl[ch]) {
442
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
443
                        if (ch == 2 && s->phase_flags[bnd])
444
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
445
                    }
446
                }
447
                i++;
448
            }
449
        } while(s->cpl_band_struct[subbnd]);
450
    }
451
}
452

    
453
/**
454
 * Grouped mantissas for 3-level 5-level and 11-level quantization
455
 */
456
typedef struct {
457
    int b1_mant[3];
458
    int b2_mant[3];
459
    int b4_mant[2];
460
    int b1ptr;
461
    int b2ptr;
462
    int b4ptr;
463
} mant_groups;
464

    
465
/**
466
 * Get the transform coefficients for a particular channel
467
 * reference: Section 7.3 Quantization and Decoding of Mantissas
468
 */
469
static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
470
{
471
    GetBitContext *gbc = &s->gbc;
472
    int i, gcode, tbap, start, end;
473
    uint8_t *exps;
474
    uint8_t *bap;
475
    int *coeffs;
476

    
477
    exps = s->dexps[ch_index];
478
    bap = s->bap[ch_index];
479
    coeffs = s->fixed_coeffs[ch_index];
480
    start = s->start_freq[ch_index];
481
    end = s->end_freq[ch_index];
482

    
483
    for (i = start; i < end; i++) {
484
        tbap = bap[i];
485
        switch (tbap) {
486
            case 0:
487
                coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 4194304;
488
                break;
489

    
490
            case 1:
491
                if(m->b1ptr > 2) {
492
                    gcode = get_bits(gbc, 5);
493
                    m->b1_mant[0] = b1_mantissas[gcode][0];
494
                    m->b1_mant[1] = b1_mantissas[gcode][1];
495
                    m->b1_mant[2] = b1_mantissas[gcode][2];
496
                    m->b1ptr = 0;
497
                }
498
                coeffs[i] = m->b1_mant[m->b1ptr++];
499
                break;
500

    
501
            case 2:
502
                if(m->b2ptr > 2) {
503
                    gcode = get_bits(gbc, 7);
504
                    m->b2_mant[0] = b2_mantissas[gcode][0];
505
                    m->b2_mant[1] = b2_mantissas[gcode][1];
506
                    m->b2_mant[2] = b2_mantissas[gcode][2];
507
                    m->b2ptr = 0;
508
                }
509
                coeffs[i] = m->b2_mant[m->b2ptr++];
510
                break;
511

    
512
            case 3:
513
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
514
                break;
515

    
516
            case 4:
517
                if(m->b4ptr > 1) {
518
                    gcode = get_bits(gbc, 7);
519
                    m->b4_mant[0] = b4_mantissas[gcode][0];
520
                    m->b4_mant[1] = b4_mantissas[gcode][1];
521
                    m->b4ptr = 0;
522
                }
523
                coeffs[i] = m->b4_mant[m->b4ptr++];
524
                break;
525

    
526
            case 5:
527
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
528
                break;
529

    
530
            default: {
531
                /* asymmetric dequantization */
532
                int qlevel = quantization_tab[tbap];
533
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
534
                break;
535
            }
536
        }
537
        coeffs[i] >>= exps[i];
538
    }
539
}
540

    
541
/**
542
 * Remove random dithering from coefficients with zero-bit mantissas
543
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
544
 */
545
static void remove_dithering(AC3DecodeContext *s) {
546
    int ch, i;
547
    int end=0;
548
    int *coeffs;
549
    uint8_t *bap;
550

    
551
    for(ch=1; ch<=s->fbw_channels; ch++) {
552
        if(!s->dither_flag[ch]) {
553
            coeffs = s->fixed_coeffs[ch];
554
            bap = s->bap[ch];
555
            if(s->channel_in_cpl[ch])
556
                end = s->start_freq[CPL_CH];
557
            else
558
                end = s->end_freq[ch];
559
            for(i=0; i<end; i++) {
560
                if(!bap[i])
561
                    coeffs[i] = 0;
562
            }
563
            if(s->channel_in_cpl[ch]) {
564
                bap = s->bap[CPL_CH];
565
                for(; i<s->end_freq[CPL_CH]; i++) {
566
                    if(!bap[i])
567
                        coeffs[i] = 0;
568
                }
569
            }
570
        }
571
    }
572
}
573

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

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

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

    
605
    /* if any channel doesn't use dithering, zero appropriate coefficients */
606
    if(!s->dither_all)
607
        remove_dithering(s);
608
}
609

    
610
/**
611
 * Stereo rematrixing.
612
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
613
 */
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
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
623
        if(s->rematrixing_flags[bnd]) {
624
            bndend = FFMIN(end, rematrix_band_tab[bnd+1]);
625
            for(i=rematrix_band_tab[bnd]; i<bndend; i++) {
626
                tmp0 = s->fixed_coeffs[1][i];
627
                tmp1 = s->fixed_coeffs[2][i];
628
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
629
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
630
            }
631
        }
632
    }
633
}
634

    
635
/**
636
 * Perform the 256-point IMDCT
637
 */
638
static void do_imdct_256(AC3DecodeContext *s, int chindex)
639
{
640
    int i, k;
641
    DECLARE_ALIGNED_16(float, x[128]);
642
    FFTComplex z[2][64];
643
    float *o_ptr = s->tmp_output;
644

    
645
    for(i=0; i<2; i++) {
646
        /* de-interleave coefficients */
647
        for(k=0; k<128; k++) {
648
            x[k] = s->transform_coeffs[chindex][2*k+i];
649
        }
650

    
651
        /* run standard IMDCT */
652
        s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);
653

    
654
        /* reverse the post-rotation & reordering from standard IMDCT */
655
        for(k=0; k<32; k++) {
656
            z[i][32+k].re = -o_ptr[128+2*k];
657
            z[i][32+k].im = -o_ptr[2*k];
658
            z[i][31-k].re =  o_ptr[2*k+1];
659
            z[i][31-k].im =  o_ptr[128+2*k+1];
660
        }
661
    }
662

    
663
    /* apply AC-3 post-rotation & reordering */
664
    for(k=0; k<64; k++) {
665
        o_ptr[    2*k  ] = -z[0][   k].im;
666
        o_ptr[    2*k+1] =  z[0][63-k].re;
667
        o_ptr[128+2*k  ] = -z[0][   k].re;
668
        o_ptr[128+2*k+1] =  z[0][63-k].im;
669
        o_ptr[256+2*k  ] = -z[1][   k].re;
670
        o_ptr[256+2*k+1] =  z[1][63-k].im;
671
        o_ptr[384+2*k  ] =  z[1][   k].im;
672
        o_ptr[384+2*k+1] = -z[1][63-k].re;
673
    }
674
}
675

    
676
/**
677
 * Inverse MDCT Transform.
678
 * Convert frequency domain coefficients to time-domain audio samples.
679
 * reference: Section 7.9.4 Transformation Equations
680
 */
681
static inline void do_imdct(AC3DecodeContext *s, int channels)
682
{
683
    int ch;
684

    
685
    for (ch=1; ch<=channels; ch++) {
686
        if (s->block_switch[ch]) {
687
            do_imdct_256(s, ch);
688
        } else {
689
            s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
690
                                        s->transform_coeffs[ch], s->tmp_imdct);
691
        }
692
        /* For the first half of the block, apply the window, add the delay
693
           from the previous block, and send to output */
694
        s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,
695
                                     s->window, s->delay[ch-1], 0, 256, 1);
696
        /* For the second half of the block, apply the window and store the
697
           samples to delay, to be combined with the next block */
698
        s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,
699
                                   s->window, 256);
700
    }
701
}
702

    
703
/**
704
 * Downmix the output to mono or stereo.
705
 */
706
static void ac3_downmix(AC3DecodeContext *s,
707
                        float samples[AC3_MAX_CHANNELS][256], int ch_offset)
708
{
709
    int i, j;
710
    float v0, v1;
711

    
712
    for(i=0; i<256; i++) {
713
        v0 = v1 = 0.0f;
714
        for(j=0; j<s->fbw_channels; j++) {
715
            v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
716
            v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
717
        }
718
        v0 *= s->downmix_coeff_adjust[0];
719
        v1 *= s->downmix_coeff_adjust[1];
720
        if(s->output_mode == AC3_CHMODE_MONO) {
721
            samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
722
        } else if(s->output_mode == AC3_CHMODE_STEREO) {
723
            samples[  ch_offset][i] = v0;
724
            samples[1+ch_offset][i] = v1;
725
        }
726
    }
727
}
728

    
729
/**
730
 * Upmix delay samples from stereo to original channel layout.
731
 */
732
static void ac3_upmix_delay(AC3DecodeContext *s)
733
{
734
    int channel_data_size = sizeof(s->delay[0]);
735
    switch(s->channel_mode) {
736
        case AC3_CHMODE_DUALMONO:
737
        case AC3_CHMODE_STEREO:
738
            /* upmix mono to stereo */
739
            memcpy(s->delay[1], s->delay[0], channel_data_size);
740
            break;
741
        case AC3_CHMODE_2F2R:
742
            memset(s->delay[3], 0, channel_data_size);
743
        case AC3_CHMODE_2F1R:
744
            memset(s->delay[2], 0, channel_data_size);
745
            break;
746
        case AC3_CHMODE_3F2R:
747
            memset(s->delay[4], 0, channel_data_size);
748
        case AC3_CHMODE_3F1R:
749
            memset(s->delay[3], 0, channel_data_size);
750
        case AC3_CHMODE_3F:
751
            memcpy(s->delay[2], s->delay[1], channel_data_size);
752
            memset(s->delay[1], 0, channel_data_size);
753
            break;
754
    }
755
}
756

    
757
/**
758
 * Parse an audio block from AC-3 bitstream.
759
 */
760
static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)
761
{
762
    int fbw_channels = s->fbw_channels;
763
    int channel_mode = s->channel_mode;
764
    int i, bnd, seg, ch;
765
    int different_transforms;
766
    int downmix_output;
767
    GetBitContext *gbc = &s->gbc;
768
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
769

    
770
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
771

    
772
    /* block switch flags */
773
    different_transforms = 0;
774
    for (ch = 1; ch <= fbw_channels; ch++) {
775
        s->block_switch[ch] = get_bits1(gbc);
776
        if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
777
            different_transforms = 1;
778
    }
779

    
780
    /* dithering flags */
781
    s->dither_all = 1;
782
    for (ch = 1; ch <= fbw_channels; ch++) {
783
        s->dither_flag[ch] = get_bits1(gbc);
784
        if(!s->dither_flag[ch])
785
            s->dither_all = 0;
786
    }
787

    
788
    /* dynamic range */
789
    i = !(s->channel_mode);
790
    do {
791
        if(get_bits1(gbc)) {
792
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
793
                                  s->avctx->drc_scale)+1.0;
794
        } else if(blk == 0) {
795
            s->dynamic_range[i] = 1.0f;
796
        }
797
    } while(i--);
798

    
799
    /* coupling strategy */
800
    if (get_bits1(gbc)) {
801
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
802
        s->cpl_in_use = get_bits1(gbc);
803
        if (s->cpl_in_use) {
804
            /* coupling in use */
805
            int cpl_begin_freq, cpl_end_freq;
806

    
807
            if (channel_mode < AC3_CHMODE_STEREO) {
808
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
809
                return -1;
810
            }
811

    
812
            /* determine which channels are coupled */
813
            for (ch = 1; ch <= fbw_channels; ch++)
814
                s->channel_in_cpl[ch] = get_bits1(gbc);
815

    
816
            /* phase flags in use */
817
            if (channel_mode == AC3_CHMODE_STEREO)
818
                s->phase_flags_in_use = get_bits1(gbc);
819

    
820
            /* coupling frequency range and band structure */
821
            cpl_begin_freq = get_bits(gbc, 4);
822
            cpl_end_freq = get_bits(gbc, 4);
823
            if (3 + cpl_end_freq - cpl_begin_freq < 0) {
824
                av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
825
                return -1;
826
            }
827
            s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
828
            s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
829
            s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
830
            for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
831
                if (get_bits1(gbc)) {
832
                    s->cpl_band_struct[bnd] = 1;
833
                    s->num_cpl_bands--;
834
                }
835
            }
836
            s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
837
        } else {
838
            /* coupling not in use */
839
            for (ch = 1; ch <= fbw_channels; ch++)
840
                s->channel_in_cpl[ch] = 0;
841
        }
842
    } else if (!blk) {
843
        av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
844
        return -1;
845
    }
846

    
847
    /* coupling coordinates */
848
    if (s->cpl_in_use) {
849
        int cpl_coords_exist = 0;
850

    
851
        for (ch = 1; ch <= fbw_channels; ch++) {
852
            if (s->channel_in_cpl[ch]) {
853
                if (get_bits1(gbc)) {
854
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
855
                    cpl_coords_exist = 1;
856
                    master_cpl_coord = 3 * get_bits(gbc, 2);
857
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
858
                        cpl_coord_exp = get_bits(gbc, 4);
859
                        cpl_coord_mant = get_bits(gbc, 4);
860
                        if (cpl_coord_exp == 15)
861
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
862
                        else
863
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
864
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
865
                    }
866
                } else if (!blk) {
867
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
868
                    return -1;
869
                }
870
            }
871
        }
872
        /* phase flags */
873
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
874
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
875
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
876
            }
877
        }
878
    }
879

    
880
    /* stereo rematrixing strategy and band structure */
881
    if (channel_mode == AC3_CHMODE_STEREO) {
882
        if (get_bits1(gbc)) {
883
            s->num_rematrixing_bands = 4;
884
            if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)
885
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
886
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
887
                s->rematrixing_flags[bnd] = get_bits1(gbc);
888
        } else if (!blk) {
889
            av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
890
            return -1;
891
        }
892
    }
893

    
894
    /* exponent strategies for each channel */
895
    s->exp_strategy[CPL_CH] = EXP_REUSE;
896
    s->exp_strategy[s->lfe_ch] = EXP_REUSE;
897
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
898
        if(ch == s->lfe_ch)
899
            s->exp_strategy[ch] = get_bits(gbc, 1);
900
        else
901
            s->exp_strategy[ch] = get_bits(gbc, 2);
902
        if(s->exp_strategy[ch] != EXP_REUSE)
903
            bit_alloc_stages[ch] = 3;
904
    }
905

    
906
    /* channel bandwidth */
907
    for (ch = 1; ch <= fbw_channels; ch++) {
908
        s->start_freq[ch] = 0;
909
        if (s->exp_strategy[ch] != EXP_REUSE) {
910
            int prev = s->end_freq[ch];
911
            if (s->channel_in_cpl[ch])
912
                s->end_freq[ch] = s->start_freq[CPL_CH];
913
            else {
914
                int bandwidth_code = get_bits(gbc, 6);
915
                if (bandwidth_code > 60) {
916
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
917
                    return -1;
918
                }
919
                s->end_freq[ch] = bandwidth_code * 3 + 73;
920
            }
921
            if(blk > 0 && s->end_freq[ch] != prev)
922
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
923
        }
924
    }
925
    s->start_freq[s->lfe_ch] = 0;
926
    s->end_freq[s->lfe_ch] = 7;
927

    
928
    /* decode exponents for each channel */
929
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
930
        if (s->exp_strategy[ch] != EXP_REUSE) {
931
            int group_size, num_groups;
932
            group_size = 3 << (s->exp_strategy[ch] - 1);
933
            if(ch == CPL_CH)
934
                num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size;
935
            else if(ch == s->lfe_ch)
936
                num_groups = 2;
937
            else
938
                num_groups = (s->end_freq[ch] + group_size - 4) / group_size;
939
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
940
            decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0],
941
                             &s->dexps[ch][s->start_freq[ch]+!!ch]);
942
            if(ch != CPL_CH && ch != s->lfe_ch)
943
                skip_bits(gbc, 2); /* skip gainrng */
944
        }
945
    }
946

    
947
    /* bit allocation information */
948
    if (get_bits1(gbc)) {
949
        s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
950
        s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
951
        s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
952
        s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
953
        s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
954
        for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
955
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
956
        }
957
    } else if (!blk) {
958
        av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
959
        return -1;
960
    }
961

    
962
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
963
    if (get_bits1(gbc)) {
964
        int csnr;
965
        csnr = (get_bits(gbc, 6) - 15) << 4;
966
        for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
967
            s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
968
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
969
        }
970
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
971
    } else if (!blk) {
972
        av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
973
        return -1;
974
    }
975

    
976
    /* coupling leak information */
977
    if (s->cpl_in_use) {
978
        if (get_bits1(gbc)) {
979
            s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
980
            s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
981
            bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
982
        } else if (!blk) {
983
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
984
            return -1;
985
        }
986
    }
987

    
988
    /* delta bit allocation information */
989
    if (get_bits1(gbc)) {
990
        /* delta bit allocation exists (strategy) */
991
        for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
992
            s->dba_mode[ch] = get_bits(gbc, 2);
993
            if (s->dba_mode[ch] == DBA_RESERVED) {
994
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
995
                return -1;
996
            }
997
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
998
        }
999
        /* channel delta offset, len and bit allocation */
1000
        for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1001
            if (s->dba_mode[ch] == DBA_NEW) {
1002
                s->dba_nsegs[ch] = get_bits(gbc, 3);
1003
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1004
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1005
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1006
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1007
                }
1008
                /* run last 2 bit allocation stages if new dba values */
1009
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1010

    
1011
            }
1012
        }
1013
    } else if(blk == 0) {
1014
        for(ch=0; ch<=s->channels; ch++) {
1015
            s->dba_mode[ch] = DBA_NONE;
1016
        }
1017
    }
1018

    
1019
    /* Bit allocation */
1020
    for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
1021
        if(bit_alloc_stages[ch] > 2) {
1022
            /* Exponent mapping into PSD and PSD integration */
1023
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1024
                                      s->start_freq[ch], s->end_freq[ch],
1025
                                      s->psd[ch], s->band_psd[ch]);
1026
        }
1027
        if(bit_alloc_stages[ch] > 1) {
1028
            /* Compute excitation function, Compute masking curve, and
1029
               Apply delta bit allocation */
1030
            ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1031
                                       s->start_freq[ch], s->end_freq[ch],
1032
                                       s->fast_gain[ch], (ch == s->lfe_ch),
1033
                                       s->dba_mode[ch], s->dba_nsegs[ch],
1034
                                       s->dba_offsets[ch], s->dba_lengths[ch],
1035
                                       s->dba_values[ch], s->mask[ch]);
1036
        }
1037
        if(bit_alloc_stages[ch] > 0) {
1038
            /* Compute bit allocation */
1039
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1040
                                      s->start_freq[ch], s->end_freq[ch],
1041
                                      s->snr_offset[ch],
1042
                                      s->bit_alloc_params.floor,
1043
                                      s->bap[ch]);
1044
        }
1045
    }
1046

    
1047
    /* unused dummy data */
1048
    if (get_bits1(gbc)) {
1049
        int skipl = get_bits(gbc, 9);
1050
        while(skipl--)
1051
            skip_bits(gbc, 8);
1052
    }
1053

    
1054
    /* unpack the transform coefficients
1055
       this also uncouples channels if coupling is in use. */
1056
    get_transform_coeffs(s);
1057

    
1058
    /* recover coefficients if rematrixing is in use */
1059
    if(s->channel_mode == AC3_CHMODE_STEREO)
1060
        do_rematrixing(s);
1061

    
1062
    /* apply scaling to coefficients (headroom, dynrng) */
1063
    for(ch=1; ch<=s->channels; ch++) {
1064
        float gain = s->mul_bias / 4194304.0f;
1065
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1066
            gain *= s->dynamic_range[ch-1];
1067
        } else {
1068
            gain *= s->dynamic_range[0];
1069
        }
1070
        for(i=0; i<256; i++) {
1071
            s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
1072
        }
1073
    }
1074

    
1075
    /* downmix and MDCT. order depends on whether block switching is used for
1076
       any channel in this block. this is because coefficients for the long
1077
       and short transforms cannot be mixed. */
1078
    downmix_output = s->channels != s->out_channels &&
1079
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1080
                     s->fbw_channels == s->out_channels);
1081
    if(different_transforms) {
1082
        /* the delay samples have already been downmixed, so we upmix the delay
1083
           samples in order to reconstruct all channels before downmixing. */
1084
        if(s->downmixed) {
1085
            s->downmixed = 0;
1086
            ac3_upmix_delay(s);
1087
        }
1088

    
1089
        do_imdct(s, s->channels);
1090

    
1091
        if(downmix_output) {
1092
            ac3_downmix(s, s->output, 0);
1093
        }
1094
    } else {
1095
        if(downmix_output) {
1096
            ac3_downmix(s, s->transform_coeffs, 1);
1097
        }
1098

    
1099
        if(!s->downmixed) {
1100
            s->downmixed = 1;
1101
            ac3_downmix(s, s->delay, 0);
1102
        }
1103

    
1104
        do_imdct(s, s->out_channels);
1105
    }
1106

    
1107
    /* convert float to 16-bit integer */
1108
    for(ch=0; ch<s->out_channels; ch++) {
1109
        for(i=0; i<256; i++) {
1110
            s->output[ch][i] += s->add_bias;
1111
        }
1112
        s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);
1113
    }
1114

    
1115
    return 0;
1116
}
1117

    
1118
/**
1119
 * Decode a single AC-3 frame.
1120
 */
1121
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1122
                            const uint8_t *buf, int buf_size)
1123
{
1124
    AC3DecodeContext *s = avctx->priv_data;
1125
    int16_t *out_samples = (int16_t *)data;
1126
    int i, blk, ch, err;
1127

    
1128
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1129
    if (s->input_buffer) {
1130
        /* copy input buffer to decoder context to avoid reading past the end
1131
           of the buffer, which can be caused by a damaged input stream. */
1132
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1133
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1134
    } else {
1135
        init_get_bits(&s->gbc, buf, buf_size * 8);
1136
    }
1137

    
1138
    /* parse the syncinfo */
1139
    *data_size = 0;
1140
    err = ac3_parse_header(s);
1141

    
1142
    /* check that reported frame size fits in input buffer */
1143
    if(s->frame_size > buf_size) {
1144
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1145
        err = AC3_PARSE_ERROR_FRAME_SIZE;
1146
    }
1147

    
1148
    /* check for crc mismatch */
1149
    if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1150
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1151
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1152
            err = AC3_PARSE_ERROR_CRC;
1153
        }
1154
    }
1155

    
1156
    /* parse the syncinfo */
1157
    if(err && err != AC3_PARSE_ERROR_CRC) {
1158
        switch(err) {
1159
            case AC3_PARSE_ERROR_SYNC:
1160
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1161
                break;
1162
            case AC3_PARSE_ERROR_BSID:
1163
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1164
                break;
1165
            case AC3_PARSE_ERROR_SAMPLE_RATE:
1166
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1167
                break;
1168
            case AC3_PARSE_ERROR_FRAME_SIZE:
1169
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1170
                break;
1171
            case AC3_PARSE_ERROR_FRAME_TYPE:
1172
                av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1173
                break;
1174
            default:
1175
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1176
                break;
1177
        }
1178
    }
1179

    
1180
    /* if frame is ok, set audio parameters */
1181
    if (!err) {
1182
        avctx->sample_rate = s->sample_rate;
1183
        avctx->bit_rate = s->bit_rate;
1184

    
1185
        /* channel config */
1186
        s->out_channels = s->channels;
1187
        s->output_mode = s->channel_mode;
1188
        if(s->lfe_on)
1189
            s->output_mode |= AC3_OUTPUT_LFEON;
1190
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1191
                avctx->request_channels < s->channels) {
1192
            s->out_channels = avctx->request_channels;
1193
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1194
        }
1195
        avctx->channels = s->out_channels;
1196

    
1197
        /* set downmixing coefficients if needed */
1198
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1199
                s->fbw_channels == s->out_channels)) {
1200
            set_downmix_coeffs(s);
1201
        }
1202
    } else if (!s->out_channels) {
1203
        s->out_channels = avctx->channels;
1204
        if(s->out_channels < s->channels)
1205
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1206
    }
1207

    
1208
    /* parse the audio blocks */
1209
    for (blk = 0; blk < NB_BLOCKS; blk++) {
1210
        if (!err && ac3_parse_audio_block(s, blk)) {
1211
            av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1212
        }
1213
        for (i = 0; i < 256; i++)
1214
            for (ch = 0; ch < s->out_channels; ch++)
1215
                *(out_samples++) = s->int_output[ch][i];
1216
    }
1217
    *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t);
1218
    return s->frame_size;
1219
}
1220

    
1221
/**
1222
 * Uninitialize the AC-3 decoder.
1223
 */
1224
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1225
{
1226
    AC3DecodeContext *s = avctx->priv_data;
1227
    ff_mdct_end(&s->imdct_512);
1228
    ff_mdct_end(&s->imdct_256);
1229

    
1230
    av_freep(&s->input_buffer);
1231

    
1232
    return 0;
1233
}
1234

    
1235
AVCodec ac3_decoder = {
1236
    .name = "ac3",
1237
    .type = CODEC_TYPE_AUDIO,
1238
    .id = CODEC_ID_AC3,
1239
    .priv_data_size = sizeof (AC3DecodeContext),
1240
    .init = ac3_decode_init,
1241
    .close = ac3_decode_end,
1242
    .decode = ac3_decode_frame,
1243
    .long_name = "ATSC A/52 / AC-3",
1244
};