Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ bd98e9e2

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 int 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
    return 0;
541
}
542

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

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

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

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

    
587
    for (ch = 1; ch <= s->channels; ch++) {
588
        /* transform coefficients for full-bandwidth channel */
589
        if (get_transform_coeffs_ch(s, ch, &m))
590
            return -1;
591
        /* tranform coefficients for coupling channel come right after the
592
           coefficients for the first coupled channel*/
593
        if (s->channel_in_cpl[ch])  {
594
            if (!got_cplchan) {
595
                if (get_transform_coeffs_ch(s, CPL_CH, &m)) {
596
                    av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n");
597
                    return -1;
598
                }
599
                uncouple_channels(s);
600
                got_cplchan = 1;
601
            }
602
            end = s->end_freq[CPL_CH];
603
        } else {
604
            end = s->end_freq[ch];
605
        }
606
        do
607
            s->fixed_coeffs[ch][end] = 0;
608
        while(++end < 256);
609
    }
610

    
611
    /* if any channel doesn't use dithering, zero appropriate coefficients */
612
    if(!s->dither_all)
613
        remove_dithering(s);
614

    
615
    return 0;
616
}
617

    
618
/**
619
 * Stereo rematrixing.
620
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
621
 */
622
static void do_rematrixing(AC3DecodeContext *s)
623
{
624
    int bnd, i;
625
    int end, bndend;
626
    int tmp0, tmp1;
627

    
628
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
629

    
630
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
631
        if(s->rematrixing_flags[bnd]) {
632
            bndend = FFMIN(end, rematrix_band_tab[bnd+1]);
633
            for(i=rematrix_band_tab[bnd]; i<bndend; i++) {
634
                tmp0 = s->fixed_coeffs[1][i];
635
                tmp1 = s->fixed_coeffs[2][i];
636
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
637
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
638
            }
639
        }
640
    }
641
}
642

    
643
/**
644
 * Perform the 256-point IMDCT
645
 */
646
static void do_imdct_256(AC3DecodeContext *s, int chindex)
647
{
648
    int i, k;
649
    DECLARE_ALIGNED_16(float, x[128]);
650
    FFTComplex z[2][64];
651
    float *o_ptr = s->tmp_output;
652

    
653
    for(i=0; i<2; i++) {
654
        /* de-interleave coefficients */
655
        for(k=0; k<128; k++) {
656
            x[k] = s->transform_coeffs[chindex][2*k+i];
657
        }
658

    
659
        /* run standard IMDCT */
660
        s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);
661

    
662
        /* reverse the post-rotation & reordering from standard IMDCT */
663
        for(k=0; k<32; k++) {
664
            z[i][32+k].re = -o_ptr[128+2*k];
665
            z[i][32+k].im = -o_ptr[2*k];
666
            z[i][31-k].re =  o_ptr[2*k+1];
667
            z[i][31-k].im =  o_ptr[128+2*k+1];
668
        }
669
    }
670

    
671
    /* apply AC-3 post-rotation & reordering */
672
    for(k=0; k<64; k++) {
673
        o_ptr[    2*k  ] = -z[0][   k].im;
674
        o_ptr[    2*k+1] =  z[0][63-k].re;
675
        o_ptr[128+2*k  ] = -z[0][   k].re;
676
        o_ptr[128+2*k+1] =  z[0][63-k].im;
677
        o_ptr[256+2*k  ] = -z[1][   k].re;
678
        o_ptr[256+2*k+1] =  z[1][63-k].im;
679
        o_ptr[384+2*k  ] =  z[1][   k].im;
680
        o_ptr[384+2*k+1] = -z[1][63-k].re;
681
    }
682
}
683

    
684
/**
685
 * Inverse MDCT Transform.
686
 * Convert frequency domain coefficients to time-domain audio samples.
687
 * reference: Section 7.9.4 Transformation Equations
688
 */
689
static inline void do_imdct(AC3DecodeContext *s, int channels)
690
{
691
    int ch;
692

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

    
711
/**
712
 * Downmix the output to mono or stereo.
713
 */
714
static void ac3_downmix(AC3DecodeContext *s,
715
                        float samples[AC3_MAX_CHANNELS][256], int ch_offset)
716
{
717
    int i, j;
718
    float v0, v1;
719

    
720
    for(i=0; i<256; i++) {
721
        v0 = v1 = 0.0f;
722
        for(j=0; j<s->fbw_channels; j++) {
723
            v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
724
            v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
725
        }
726
        v0 *= s->downmix_coeff_adjust[0];
727
        v1 *= s->downmix_coeff_adjust[1];
728
        if(s->output_mode == AC3_CHMODE_MONO) {
729
            samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
730
        } else if(s->output_mode == AC3_CHMODE_STEREO) {
731
            samples[  ch_offset][i] = v0;
732
            samples[1+ch_offset][i] = v1;
733
        }
734
    }
735
}
736

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

    
765
/**
766
 * Parse an audio block from AC-3 bitstream.
767
 */
768
static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)
769
{
770
    int fbw_channels = s->fbw_channels;
771
    int channel_mode = s->channel_mode;
772
    int i, bnd, seg, ch;
773
    int different_transforms;
774
    int downmix_output;
775
    GetBitContext *gbc = &s->gbc;
776
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
777

    
778
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
779

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

    
788
    /* dithering flags */
789
    s->dither_all = 1;
790
    for (ch = 1; ch <= fbw_channels; ch++) {
791
        s->dither_flag[ch] = get_bits1(gbc);
792
        if(!s->dither_flag[ch])
793
            s->dither_all = 0;
794
    }
795

    
796
    /* dynamic range */
797
    i = !(s->channel_mode);
798
    do {
799
        if(get_bits1(gbc)) {
800
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
801
                                  s->avctx->drc_scale)+1.0;
802
        } else if(blk == 0) {
803
            s->dynamic_range[i] = 1.0f;
804
        }
805
    } while(i--);
806

    
807
    /* coupling strategy */
808
    if (get_bits1(gbc)) {
809
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
810
        s->cpl_in_use = get_bits1(gbc);
811
        if (s->cpl_in_use) {
812
            /* coupling in use */
813
            int cpl_begin_freq, cpl_end_freq;
814

    
815
            if (channel_mode < AC3_CHMODE_STEREO) {
816
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
817
                return -1;
818
            }
819

    
820
            /* determine which channels are coupled */
821
            for (ch = 1; ch <= fbw_channels; ch++)
822
                s->channel_in_cpl[ch] = get_bits1(gbc);
823

    
824
            /* phase flags in use */
825
            if (channel_mode == AC3_CHMODE_STEREO)
826
                s->phase_flags_in_use = get_bits1(gbc);
827

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

    
855
    /* coupling coordinates */
856
    if (s->cpl_in_use) {
857
        int cpl_coords_exist = 0;
858

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

    
888
    /* stereo rematrixing strategy and band structure */
889
    if (channel_mode == AC3_CHMODE_STEREO) {
890
        if (get_bits1(gbc)) {
891
            s->num_rematrixing_bands = 4;
892
            if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)
893
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
894
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
895
                s->rematrixing_flags[bnd] = get_bits1(gbc);
896
        } else if (!blk) {
897
            av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
898
            return -1;
899
        }
900
    }
901

    
902
    /* exponent strategies for each channel */
903
    s->exp_strategy[CPL_CH] = EXP_REUSE;
904
    s->exp_strategy[s->lfe_ch] = EXP_REUSE;
905
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
906
        if(ch == s->lfe_ch)
907
            s->exp_strategy[ch] = get_bits(gbc, 1);
908
        else
909
            s->exp_strategy[ch] = get_bits(gbc, 2);
910
        if(s->exp_strategy[ch] != EXP_REUSE)
911
            bit_alloc_stages[ch] = 3;
912
    }
913

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

    
936
    /* decode exponents for each channel */
937
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
938
        if (s->exp_strategy[ch] != EXP_REUSE) {
939
            int group_size, num_groups;
940
            group_size = 3 << (s->exp_strategy[ch] - 1);
941
            if(ch == CPL_CH)
942
                num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size;
943
            else if(ch == s->lfe_ch)
944
                num_groups = 2;
945
            else
946
                num_groups = (s->end_freq[ch] + group_size - 4) / group_size;
947
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
948
            decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0],
949
                             &s->dexps[ch][s->start_freq[ch]+!!ch]);
950
            if(ch != CPL_CH && ch != s->lfe_ch)
951
                skip_bits(gbc, 2); /* skip gainrng */
952
        }
953
    }
954

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

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

    
984
    /* coupling leak information */
985
    if (s->cpl_in_use) {
986
        if (get_bits1(gbc)) {
987
            s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
988
            s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
989
            bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
990
        } else if (!blk) {
991
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
992
            return -1;
993
        }
994
    }
995

    
996
    /* delta bit allocation information */
997
    if (get_bits1(gbc)) {
998
        /* delta bit allocation exists (strategy) */
999
        for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1000
            s->dba_mode[ch] = get_bits(gbc, 2);
1001
            if (s->dba_mode[ch] == DBA_RESERVED) {
1002
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1003
                return -1;
1004
            }
1005
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1006
        }
1007
        /* channel delta offset, len and bit allocation */
1008
        for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1009
            if (s->dba_mode[ch] == DBA_NEW) {
1010
                s->dba_nsegs[ch] = get_bits(gbc, 3);
1011
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1012
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1013
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1014
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1015
                }
1016
            }
1017
        }
1018
    } else if(blk == 0) {
1019
        for(ch=0; ch<=s->channels; ch++) {
1020
            s->dba_mode[ch] = DBA_NONE;
1021
        }
1022
    }
1023

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

    
1052
    /* unused dummy data */
1053
    if (get_bits1(gbc)) {
1054
        int skipl = get_bits(gbc, 9);
1055
        while(skipl--)
1056
            skip_bits(gbc, 8);
1057
    }
1058

    
1059
    /* unpack the transform coefficients
1060
       this also uncouples channels if coupling is in use. */
1061
    if (get_transform_coeffs(s)) {
1062
        av_log(s->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");
1063
        return -1;
1064
    }
1065

    
1066
    /* recover coefficients if rematrixing is in use */
1067
    if(s->channel_mode == AC3_CHMODE_STEREO)
1068
        do_rematrixing(s);
1069

    
1070
    /* apply scaling to coefficients (headroom, dynrng) */
1071
    for(ch=1; ch<=s->channels; ch++) {
1072
        float gain = s->mul_bias / 4194304.0f;
1073
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1074
            gain *= s->dynamic_range[ch-1];
1075
        } else {
1076
            gain *= s->dynamic_range[0];
1077
        }
1078
        for(i=0; i<256; i++) {
1079
            s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
1080
        }
1081
    }
1082

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

    
1097
        do_imdct(s, s->channels);
1098

    
1099
        if(downmix_output) {
1100
            ac3_downmix(s, s->output, 0);
1101
        }
1102
    } else {
1103
        if(downmix_output) {
1104
            ac3_downmix(s, s->transform_coeffs, 1);
1105
        }
1106

    
1107
        if(!s->downmixed) {
1108
            s->downmixed = 1;
1109
            ac3_downmix(s, s->delay, 0);
1110
        }
1111

    
1112
        do_imdct(s, s->out_channels);
1113
    }
1114

    
1115
    /* convert float to 16-bit integer */
1116
    for(ch=0; ch<s->out_channels; ch++) {
1117
        for(i=0; i<256; i++) {
1118
            s->output[ch][i] += s->add_bias;
1119
        }
1120
        s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);
1121
    }
1122

    
1123
    return 0;
1124
}
1125

    
1126
/**
1127
 * Decode a single AC-3 frame.
1128
 */
1129
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1130
                            const uint8_t *buf, int buf_size)
1131
{
1132
    AC3DecodeContext *s = avctx->priv_data;
1133
    int16_t *out_samples = (int16_t *)data;
1134
    int i, blk, ch, err;
1135

    
1136
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1137
    if (s->input_buffer) {
1138
        /* copy input buffer to decoder context to avoid reading past the end
1139
           of the buffer, which can be caused by a damaged input stream. */
1140
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1141
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1142
    } else {
1143
        init_get_bits(&s->gbc, buf, buf_size * 8);
1144
    }
1145

    
1146
    /* parse the syncinfo */
1147
    err = ac3_parse_header(s);
1148
    if(err) {
1149
        switch(err) {
1150
            case AC3_PARSE_ERROR_SYNC:
1151
                av_log(avctx, AV_LOG_ERROR, "frame sync error : cannot use error concealment\n");
1152
                return -1;
1153
            case AC3_PARSE_ERROR_BSID:
1154
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1155
                break;
1156
            case AC3_PARSE_ERROR_SAMPLE_RATE:
1157
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1158
                break;
1159
            case AC3_PARSE_ERROR_FRAME_SIZE:
1160
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1161
                break;
1162
            case AC3_PARSE_ERROR_FRAME_TYPE:
1163
                av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1164
                break;
1165
            default:
1166
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1167
                break;
1168
        }
1169
    }
1170

    
1171
    /* check that reported frame size fits in input buffer */
1172
    if(s->frame_size > buf_size) {
1173
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1174
        return -1;
1175
    }
1176

    
1177
    /* check for crc mismatch */
1178
    if(!err && avctx->error_resilience >= FF_ER_CAREFUL) {
1179
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1180
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1181
            err = 1;
1182
        }
1183
    }
1184

    
1185
    /* if frame is ok, set audio parameters */
1186
    if (!err) {
1187
        avctx->sample_rate = s->sample_rate;
1188
        avctx->bit_rate = s->bit_rate;
1189

    
1190
        /* channel config */
1191
        s->out_channels = s->channels;
1192
        s->output_mode = s->channel_mode;
1193
        if(s->lfe_on)
1194
            s->output_mode |= AC3_OUTPUT_LFEON;
1195
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1196
                avctx->request_channels < s->channels) {
1197
            s->out_channels = avctx->request_channels;
1198
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1199
        }
1200
        avctx->channels = s->out_channels;
1201

    
1202
        /* set downmixing coefficients if needed */
1203
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1204
                s->fbw_channels == s->out_channels)) {
1205
            set_downmix_coeffs(s);
1206
        }
1207
    } else if (!s->out_channels) {
1208
        s->out_channels = avctx->channels;
1209
        if(s->out_channels < s->channels)
1210
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1211
    }
1212

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

    
1226
/**
1227
 * Uninitialize the AC-3 decoder.
1228
 */
1229
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1230
{
1231
    AC3DecodeContext *s = avctx->priv_data;
1232
    ff_mdct_end(&s->imdct_512);
1233
    ff_mdct_end(&s->imdct_256);
1234

    
1235
    av_freep(&s->input_buffer);
1236

    
1237
    return 0;
1238
}
1239

    
1240
AVCodec ac3_decoder = {
1241
    .name = "ac3",
1242
    .type = CODEC_TYPE_AUDIO,
1243
    .id = CODEC_ID_AC3,
1244
    .priv_data_size = sizeof (AC3DecodeContext),
1245
    .init = ac3_decode_init,
1246
    .close = ac3_decode_end,
1247
    .decode = ac3_decode_frame,
1248
    .long_name = "ATSC A/52 / AC-3",
1249
};