Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ c33a1967

History | View | Annotate | Download (43.1 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 "avcodec.h"
36
#include "ac3_parser.h"
37
#include "bitstream.h"
38
#include "crc.h"
39
#include "dsputil.h"
40
#include "random.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 center mix levels
93
 * reference: Section 5.4.2.4 cmixlev
94
 */
95
static const uint8_t center_levels[4] = { 2, 3, 4, 3 };
96

    
97
/**
98
 * Table for surround mix levels
99
 * reference: Section 5.4.2.5 surmixlev
100
 */
101
static const uint8_t surround_levels[4] = { 2, 4, 0, 4 };
102

    
103
/**
104
 * Table for default stereo downmixing coefficients
105
 * reference: Section 7.8.2 Downmixing Into Two Channels
106
 */
107
static const uint8_t ac3_default_coeffs[8][5][2] = {
108
    { { 1, 0 }, { 0, 1 },                               },
109
    { { 2, 2 },                                         },
110
    { { 1, 0 }, { 0, 1 },                               },
111
    { { 1, 0 }, { 3, 3 }, { 0, 1 },                     },
112
    { { 1, 0 }, { 0, 1 }, { 4, 4 },                     },
113
    { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 },           },
114
    { { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 },           },
115
    { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, },
116
};
117

    
118
/* override ac3.h to include coupling channel */
119
#undef AC3_MAX_CHANNELS
120
#define AC3_MAX_CHANNELS 7
121
#define CPL_CH 0
122

    
123
#define AC3_OUTPUT_LFEON  8
124

    
125
typedef struct {
126
    int channel_mode;                       ///< channel mode (acmod)
127
    int block_switch[AC3_MAX_CHANNELS];     ///< block switch flags
128
    int dither_flag[AC3_MAX_CHANNELS];      ///< dither flags
129
    int dither_all;                         ///< true if all channels are dithered
130
    int cpl_in_use;                         ///< coupling in use
131
    int channel_in_cpl[AC3_MAX_CHANNELS];   ///< channel in coupling
132
    int phase_flags_in_use;                 ///< phase flags in use
133
    int phase_flags[18];                    ///< phase flags
134
    int cpl_band_struct[18];                ///< coupling band structure
135
    int num_rematrixing_bands;              ///< number of rematrixing bands
136
    int rematrixing_flags[4];               ///< rematrixing flags
137
    int exp_strategy[AC3_MAX_CHANNELS];     ///< exponent strategies
138
    int snr_offset[AC3_MAX_CHANNELS];       ///< signal-to-noise ratio offsets
139
    int fast_gain[AC3_MAX_CHANNELS];        ///< fast gain values (signal-to-mask ratio)
140
    int dba_mode[AC3_MAX_CHANNELS];         ///< delta bit allocation mode
141
    int dba_nsegs[AC3_MAX_CHANNELS];        ///< number of delta segments
142
    uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets
143
    uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths
144
    uint8_t dba_values[AC3_MAX_CHANNELS][8];  ///< delta values for each segment
145

    
146
    int sample_rate;                        ///< sample frequency, in Hz
147
    int bit_rate;                           ///< stream bit rate, in bits-per-second
148
    int frame_size;                         ///< current frame size, in bytes
149

    
150
    int channels;                           ///< number of total channels
151
    int fbw_channels;                       ///< number of full-bandwidth channels
152
    int lfe_on;                             ///< lfe channel in use
153
    int lfe_ch;                             ///< index of LFE channel
154
    int output_mode;                        ///< output channel configuration
155
    int out_channels;                       ///< number of output channels
156

    
157
    int center_mix_level;                   ///< Center mix level index
158
    int surround_mix_level;                 ///< Surround mix level index
159
    float downmix_coeffs[AC3_MAX_CHANNELS][2];  ///< stereo downmix coefficients
160
    float downmix_coeff_adjust[2];          ///< adjustment needed for each output channel when downmixing
161
    float dynamic_range[2];                 ///< dynamic range
162
    int   cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates
163
    int   num_cpl_bands;                    ///< number of coupling bands
164
    int   num_cpl_subbands;                 ///< number of coupling sub bands
165
    int   start_freq[AC3_MAX_CHANNELS];     ///< start frequency bin
166
    int   end_freq[AC3_MAX_CHANNELS];       ///< end frequency bin
167
    AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters
168

    
169
    int8_t  dexps[AC3_MAX_CHANNELS][256];   ///< decoded exponents
170
    uint8_t bap[AC3_MAX_CHANNELS][256];     ///< bit allocation pointers
171
    int16_t psd[AC3_MAX_CHANNELS][256];     ///< scaled exponents
172
    int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents
173
    int16_t mask[AC3_MAX_CHANNELS][50];     ///< masking curve values
174

    
175
    int fixed_coeffs[AC3_MAX_CHANNELS][256];    ///> fixed-point transform coefficients
176
    DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]);  ///< transform coefficients
177
    int downmixed;                              ///< indicates if coeffs are currently downmixed
178

    
179
    /* For IMDCT. */
180
    MDCTContext imdct_512;                  ///< for 512 sample IMDCT
181
    MDCTContext imdct_256;                  ///< for 256 sample IMDCT
182
    DSPContext  dsp;                        ///< for optimization
183
    float       add_bias;                   ///< offset for float_to_int16 conversion
184
    float       mul_bias;                   ///< scaling for float_to_int16 conversion
185

    
186
    DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][256]);       ///< output after imdct transform and windowing
187
    DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][256]); ///< final 16-bit integer output
188
    DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][256]);        ///< delay - added to the next block
189
    DECLARE_ALIGNED_16(float, tmp_imdct[256]);                      ///< temporary storage for imdct transform
190
    DECLARE_ALIGNED_16(float, tmp_output[512]);                     ///< temporary storage for output before windowing
191
    DECLARE_ALIGNED_16(float, window[256]);                         ///< window coefficients
192

    
193
    /* Miscellaneous. */
194
    GetBitContext gbc;                      ///< bitstream reader
195
    AVRandomState dith_state;               ///< for dither generation
196
    AVCodecContext *avctx;                  ///< parent context
197
    uint8_t input_buffer[AC3_MAX_FRAME_SIZE];   ///< temp buffer to prevent overread
198
} AC3DecodeContext;
199

    
200
/**
201
 * Symmetrical Dequantization
202
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
203
 *            Tables 7.19 to 7.23
204
 */
205
static inline int
206
symmetric_dequant(int code, int levels)
207
{
208
    return ((code - (levels >> 1)) << 24) / levels;
209
}
210

    
211
/*
212
 * Initialize tables at runtime.
213
 */
214
static av_cold void ac3_tables_init(void)
215
{
216
    int i;
217

    
218
    /* generate grouped mantissa tables
219
       reference: Section 7.3.5 Ungrouping of Mantissas */
220
    for(i=0; i<32; i++) {
221
        /* bap=1 mantissas */
222
        b1_mantissas[i][0] = symmetric_dequant( i / 9     , 3);
223
        b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3);
224
        b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3);
225
    }
226
    for(i=0; i<128; i++) {
227
        /* bap=2 mantissas */
228
        b2_mantissas[i][0] = symmetric_dequant( i / 25     , 5);
229
        b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5);
230
        b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5);
231

    
232
        /* bap=4 mantissas */
233
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
234
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
235
    }
236
    /* generate ungrouped mantissa tables
237
       reference: Tables 7.21 and 7.23 */
238
    for(i=0; i<7; i++) {
239
        /* bap=3 mantissas */
240
        b3_mantissas[i] = symmetric_dequant(i, 7);
241
    }
242
    for(i=0; i<15; i++) {
243
        /* bap=5 mantissas */
244
        b5_mantissas[i] = symmetric_dequant(i, 15);
245
    }
246

    
247
    /* generate dynamic range table
248
       reference: Section 7.7.1 Dynamic Range Control */
249
    for(i=0; i<256; i++) {
250
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
251
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
252
    }
253

    
254
    /* generate exponent tables
255
       reference: Section 7.1.3 Exponent Decoding */
256
    for(i=0; i<128; i++) {
257
        exp_ungroup_tab[i][0] =  i / 25;
258
        exp_ungroup_tab[i][1] = (i % 25) / 5;
259
        exp_ungroup_tab[i][2] = (i % 25) % 5;
260
    }
261
}
262

    
263

    
264
/**
265
 * AVCodec initialization
266
 */
267
static av_cold int ac3_decode_init(AVCodecContext *avctx)
268
{
269
    AC3DecodeContext *s = avctx->priv_data;
270
    s->avctx = avctx;
271

    
272
    ac3_common_init();
273
    ac3_tables_init();
274
    ff_mdct_init(&s->imdct_256, 8, 1);
275
    ff_mdct_init(&s->imdct_512, 9, 1);
276
    ff_kbd_window_init(s->window, 5.0, 256);
277
    dsputil_init(&s->dsp, avctx);
278
    av_init_random(0, &s->dith_state);
279

    
280
    /* set bias values for float to int16 conversion */
281
    if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
282
        s->add_bias = 385.0f;
283
        s->mul_bias = 1.0f;
284
    } else {
285
        s->add_bias = 0.0f;
286
        s->mul_bias = 32767.0f;
287
    }
288

    
289
    /* allow downmixing to stereo or mono */
290
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
291
            avctx->request_channels < avctx->channels &&
292
            avctx->request_channels <= 2) {
293
        avctx->channels = avctx->request_channels;
294
    }
295
    s->downmixed = 1;
296

    
297
    return 0;
298
}
299

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

    
311
    err = ff_ac3_parse_header(gbc->buffer, &hdr);
312
    if(err)
313
        return err;
314

    
315
    if(hdr.bitstream_id > 10)
316
        return AC3_PARSE_ERROR_BSID;
317

    
318
    /* get decoding parameters from header info */
319
    s->bit_alloc_params.sr_code     = hdr.sr_code;
320
    s->channel_mode                 = hdr.channel_mode;
321
    s->lfe_on                       = hdr.lfe_on;
322
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
323
    s->sample_rate                  = hdr.sample_rate;
324
    s->bit_rate                     = hdr.bit_rate;
325
    s->channels                     = hdr.channels;
326
    s->fbw_channels                 = s->channels - s->lfe_on;
327
    s->lfe_ch                       = s->fbw_channels + 1;
328
    s->frame_size                   = hdr.frame_size;
329

    
330
    /* set default output to all source channels */
331
    s->out_channels = s->channels;
332
    s->output_mode = s->channel_mode;
333
    if(s->lfe_on)
334
        s->output_mode |= AC3_OUTPUT_LFEON;
335

    
336
    /* set default mix levels */
337
    s->center_mix_level   = 3;  // -4.5dB
338
    s->surround_mix_level = 4;  // -6.0dB
339

    
340
    /* skip over portion of header which has already been read */
341
    skip_bits(gbc, 16); // skip the sync_word
342
    skip_bits(gbc, 16); // skip crc1
343
    skip_bits(gbc, 8);  // skip fscod and frmsizecod
344
    skip_bits(gbc, 11); // skip bsid, bsmod, and acmod
345
    if(s->channel_mode == AC3_CHMODE_STEREO) {
346
        skip_bits(gbc, 2); // skip dsurmod
347
    } else {
348
        if((s->channel_mode & 1) && s->channel_mode != AC3_CHMODE_MONO)
349
            s->center_mix_level = center_levels[get_bits(gbc, 2)];
350
        if(s->channel_mode & 4)
351
            s->surround_mix_level = surround_levels[get_bits(gbc, 2)];
352
    }
353
    skip_bits1(gbc); // skip lfeon
354

    
355
    /* read the rest of the bsi. read twice for dual mono mode. */
356
    i = !(s->channel_mode);
357
    do {
358
        skip_bits(gbc, 5); // skip dialog normalization
359
        if (get_bits1(gbc))
360
            skip_bits(gbc, 8); //skip compression
361
        if (get_bits1(gbc))
362
            skip_bits(gbc, 8); //skip language code
363
        if (get_bits1(gbc))
364
            skip_bits(gbc, 7); //skip audio production information
365
    } while (i--);
366

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

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

    
376
    /* skip additional bitstream info */
377
    if (get_bits1(gbc)) {
378
        i = get_bits(gbc, 6);
379
        do {
380
            skip_bits(gbc, 8);
381
        } while(i--);
382
    }
383

    
384
    return 0;
385
}
386

    
387
/**
388
 * Set stereo downmixing coefficients based on frame header info.
389
 * reference: Section 7.8.2 Downmixing Into Two Channels
390
 */
391
static void set_downmix_coeffs(AC3DecodeContext *s)
392
{
393
    int i;
394
    float cmix = gain_levels[s->center_mix_level];
395
    float smix = gain_levels[s->surround_mix_level];
396

    
397
    for(i=0; i<s->fbw_channels; i++) {
398
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
399
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
400
    }
401
    if(s->channel_mode > 1 && s->channel_mode & 1) {
402
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
403
    }
404
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
405
        int nf = s->channel_mode - 2;
406
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
407
    }
408
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
409
        int nf = s->channel_mode - 4;
410
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
411
    }
412

    
413
    /* calculate adjustment needed for each channel to avoid clipping */
414
    s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
415
    for(i=0; i<s->fbw_channels; i++) {
416
        s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
417
        s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
418
    }
419
    s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
420
    s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
421
}
422

    
423
/**
424
 * Decode the grouped exponents according to exponent strategy.
425
 * reference: Section 7.1.3 Exponent Decoding
426
 */
427
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
428
                             uint8_t absexp, int8_t *dexps)
429
{
430
    int i, j, grp, group_size;
431
    int dexp[256];
432
    int expacc, prevexp;
433

    
434
    /* unpack groups */
435
    group_size = exp_strategy + (exp_strategy == EXP_D45);
436
    for(grp=0,i=0; grp<ngrps; grp++) {
437
        expacc = get_bits(gbc, 7);
438
        dexp[i++] = exp_ungroup_tab[expacc][0];
439
        dexp[i++] = exp_ungroup_tab[expacc][1];
440
        dexp[i++] = exp_ungroup_tab[expacc][2];
441
    }
442

    
443
    /* convert to absolute exps and expand groups */
444
    prevexp = absexp;
445
    for(i=0; i<ngrps*3; i++) {
446
        prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
447
        for(j=0; j<group_size; j++) {
448
            dexps[(i*group_size)+j] = prevexp;
449
        }
450
    }
451
}
452

    
453
/**
454
 * Generate transform coefficients for each coupled channel in the coupling
455
 * range using the coupling coefficients and coupling coordinates.
456
 * reference: Section 7.4.3 Coupling Coordinate Format
457
 */
458
static void uncouple_channels(AC3DecodeContext *s)
459
{
460
    int i, j, ch, bnd, subbnd;
461

    
462
    subbnd = -1;
463
    i = s->start_freq[CPL_CH];
464
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
465
        do {
466
            subbnd++;
467
            for(j=0; j<12; j++) {
468
                for(ch=1; ch<=s->fbw_channels; ch++) {
469
                    if(s->channel_in_cpl[ch]) {
470
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
471
                        if (ch == 2 && s->phase_flags[bnd])
472
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
473
                    }
474
                }
475
                i++;
476
            }
477
        } while(s->cpl_band_struct[subbnd]);
478
    }
479
}
480

    
481
/**
482
 * Grouped mantissas for 3-level 5-level and 11-level quantization
483
 */
484
typedef struct {
485
    int b1_mant[3];
486
    int b2_mant[3];
487
    int b4_mant[2];
488
    int b1ptr;
489
    int b2ptr;
490
    int b4ptr;
491
} mant_groups;
492

    
493
/**
494
 * Get the transform coefficients for a particular channel
495
 * reference: Section 7.3 Quantization and Decoding of Mantissas
496
 */
497
static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
498
{
499
    GetBitContext *gbc = &s->gbc;
500
    int i, gcode, tbap, start, end;
501
    uint8_t *exps;
502
    uint8_t *bap;
503
    int *coeffs;
504

    
505
    exps = s->dexps[ch_index];
506
    bap = s->bap[ch_index];
507
    coeffs = s->fixed_coeffs[ch_index];
508
    start = s->start_freq[ch_index];
509
    end = s->end_freq[ch_index];
510

    
511
    for (i = start; i < end; i++) {
512
        tbap = bap[i];
513
        switch (tbap) {
514
            case 0:
515
                coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 4194304;
516
                break;
517

    
518
            case 1:
519
                if(m->b1ptr > 2) {
520
                    gcode = get_bits(gbc, 5);
521
                    m->b1_mant[0] = b1_mantissas[gcode][0];
522
                    m->b1_mant[1] = b1_mantissas[gcode][1];
523
                    m->b1_mant[2] = b1_mantissas[gcode][2];
524
                    m->b1ptr = 0;
525
                }
526
                coeffs[i] = m->b1_mant[m->b1ptr++];
527
                break;
528

    
529
            case 2:
530
                if(m->b2ptr > 2) {
531
                    gcode = get_bits(gbc, 7);
532
                    m->b2_mant[0] = b2_mantissas[gcode][0];
533
                    m->b2_mant[1] = b2_mantissas[gcode][1];
534
                    m->b2_mant[2] = b2_mantissas[gcode][2];
535
                    m->b2ptr = 0;
536
                }
537
                coeffs[i] = m->b2_mant[m->b2ptr++];
538
                break;
539

    
540
            case 3:
541
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
542
                break;
543

    
544
            case 4:
545
                if(m->b4ptr > 1) {
546
                    gcode = get_bits(gbc, 7);
547
                    m->b4_mant[0] = b4_mantissas[gcode][0];
548
                    m->b4_mant[1] = b4_mantissas[gcode][1];
549
                    m->b4ptr = 0;
550
                }
551
                coeffs[i] = m->b4_mant[m->b4ptr++];
552
                break;
553

    
554
            case 5:
555
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
556
                break;
557

    
558
            default: {
559
                /* asymmetric dequantization */
560
                int qlevel = quantization_tab[tbap];
561
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
562
                break;
563
            }
564
        }
565
        coeffs[i] >>= exps[i];
566
    }
567

    
568
    return 0;
569
}
570

    
571
/**
572
 * Remove random dithering from coefficients with zero-bit mantissas
573
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
574
 */
575
static void remove_dithering(AC3DecodeContext *s) {
576
    int ch, i;
577
    int end=0;
578
    int *coeffs;
579
    uint8_t *bap;
580

    
581
    for(ch=1; ch<=s->fbw_channels; ch++) {
582
        if(!s->dither_flag[ch]) {
583
            coeffs = s->fixed_coeffs[ch];
584
            bap = s->bap[ch];
585
            if(s->channel_in_cpl[ch])
586
                end = s->start_freq[CPL_CH];
587
            else
588
                end = s->end_freq[ch];
589
            for(i=0; i<end; i++) {
590
                if(!bap[i])
591
                    coeffs[i] = 0;
592
            }
593
            if(s->channel_in_cpl[ch]) {
594
                bap = s->bap[CPL_CH];
595
                for(; i<s->end_freq[CPL_CH]; i++) {
596
                    if(!bap[i])
597
                        coeffs[i] = 0;
598
                }
599
            }
600
        }
601
    }
602
}
603

    
604
/**
605
 * Get the transform coefficients.
606
 */
607
static int get_transform_coeffs(AC3DecodeContext *s)
608
{
609
    int ch, end;
610
    int got_cplchan = 0;
611
    mant_groups m;
612

    
613
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
614

    
615
    for (ch = 1; ch <= s->channels; ch++) {
616
        /* transform coefficients for full-bandwidth channel */
617
        if (get_transform_coeffs_ch(s, ch, &m))
618
            return -1;
619
        /* tranform coefficients for coupling channel come right after the
620
           coefficients for the first coupled channel*/
621
        if (s->channel_in_cpl[ch])  {
622
            if (!got_cplchan) {
623
                if (get_transform_coeffs_ch(s, CPL_CH, &m)) {
624
                    av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n");
625
                    return -1;
626
                }
627
                uncouple_channels(s);
628
                got_cplchan = 1;
629
            }
630
            end = s->end_freq[CPL_CH];
631
        } else {
632
            end = s->end_freq[ch];
633
        }
634
        do
635
            s->transform_coeffs[ch][end] = 0;
636
        while(++end < 256);
637
    }
638

    
639
    /* if any channel doesn't use dithering, zero appropriate coefficients */
640
    if(!s->dither_all)
641
        remove_dithering(s);
642

    
643
    return 0;
644
}
645

    
646
/**
647
 * Stereo rematrixing.
648
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
649
 */
650
static void do_rematrixing(AC3DecodeContext *s)
651
{
652
    int bnd, i;
653
    int end, bndend;
654
    int tmp0, tmp1;
655

    
656
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
657

    
658
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
659
        if(s->rematrixing_flags[bnd]) {
660
            bndend = FFMIN(end, rematrix_band_tab[bnd+1]);
661
            for(i=rematrix_band_tab[bnd]; i<bndend; i++) {
662
                tmp0 = s->fixed_coeffs[1][i];
663
                tmp1 = s->fixed_coeffs[2][i];
664
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
665
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
666
            }
667
        }
668
    }
669
}
670

    
671
/**
672
 * Perform the 256-point IMDCT
673
 */
674
static void do_imdct_256(AC3DecodeContext *s, int chindex)
675
{
676
    int i, k;
677
    DECLARE_ALIGNED_16(float, x[128]);
678
    FFTComplex z[2][64];
679
    float *o_ptr = s->tmp_output;
680

    
681
    for(i=0; i<2; i++) {
682
        /* de-interleave coefficients */
683
        for(k=0; k<128; k++) {
684
            x[k] = s->transform_coeffs[chindex][2*k+i];
685
        }
686

    
687
        /* run standard IMDCT */
688
        s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);
689

    
690
        /* reverse the post-rotation & reordering from standard IMDCT */
691
        for(k=0; k<32; k++) {
692
            z[i][32+k].re = -o_ptr[128+2*k];
693
            z[i][32+k].im = -o_ptr[2*k];
694
            z[i][31-k].re =  o_ptr[2*k+1];
695
            z[i][31-k].im =  o_ptr[128+2*k+1];
696
        }
697
    }
698

    
699
    /* apply AC-3 post-rotation & reordering */
700
    for(k=0; k<64; k++) {
701
        o_ptr[    2*k  ] = -z[0][   k].im;
702
        o_ptr[    2*k+1] =  z[0][63-k].re;
703
        o_ptr[128+2*k  ] = -z[0][   k].re;
704
        o_ptr[128+2*k+1] =  z[0][63-k].im;
705
        o_ptr[256+2*k  ] = -z[1][   k].re;
706
        o_ptr[256+2*k+1] =  z[1][63-k].im;
707
        o_ptr[384+2*k  ] =  z[1][   k].im;
708
        o_ptr[384+2*k+1] = -z[1][63-k].re;
709
    }
710
}
711

    
712
/**
713
 * Inverse MDCT Transform.
714
 * Convert frequency domain coefficients to time-domain audio samples.
715
 * reference: Section 7.9.4 Transformation Equations
716
 */
717
static inline void do_imdct(AC3DecodeContext *s, int channels)
718
{
719
    int ch;
720

    
721
    for (ch=1; ch<=channels; ch++) {
722
        if (s->block_switch[ch]) {
723
            do_imdct_256(s, ch);
724
        } else {
725
            s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
726
                                        s->transform_coeffs[ch], s->tmp_imdct);
727
        }
728
        /* For the first half of the block, apply the window, add the delay
729
           from the previous block, and send to output */
730
        s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,
731
                                     s->window, s->delay[ch-1], 0, 256, 1);
732
        /* For the second half of the block, apply the window and store the
733
           samples to delay, to be combined with the next block */
734
        s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,
735
                                   s->window, 256);
736
    }
737
}
738

    
739
/**
740
 * Downmix the output to mono or stereo.
741
 */
742
static void ac3_downmix(AC3DecodeContext *s,
743
                        float samples[AC3_MAX_CHANNELS][256], int ch_offset)
744
{
745
    int i, j;
746
    float v0, v1;
747

    
748
    for(i=0; i<256; i++) {
749
        v0 = v1 = 0.0f;
750
        for(j=0; j<s->fbw_channels; j++) {
751
            v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
752
            v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
753
        }
754
        v0 *= s->downmix_coeff_adjust[0];
755
        v1 *= s->downmix_coeff_adjust[1];
756
        if(s->output_mode == AC3_CHMODE_MONO) {
757
            samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
758
        } else if(s->output_mode == AC3_CHMODE_STEREO) {
759
            samples[  ch_offset][i] = v0;
760
            samples[1+ch_offset][i] = v1;
761
        }
762
    }
763
}
764

    
765
/**
766
 * Upmix delay samples from stereo to original channel layout.
767
 */
768
static void ac3_upmix_delay(AC3DecodeContext *s)
769
{
770
    int channel_data_size = sizeof(s->delay[0]);
771
    switch(s->channel_mode) {
772
        case AC3_CHMODE_DUALMONO:
773
        case AC3_CHMODE_STEREO:
774
            /* upmix mono to stereo */
775
            memcpy(s->delay[1], s->delay[0], channel_data_size);
776
            break;
777
        case AC3_CHMODE_2F2R:
778
            memset(s->delay[3], 0, channel_data_size);
779
        case AC3_CHMODE_2F1R:
780
            memset(s->delay[2], 0, channel_data_size);
781
            break;
782
        case AC3_CHMODE_3F2R:
783
            memset(s->delay[4], 0, channel_data_size);
784
        case AC3_CHMODE_3F1R:
785
            memset(s->delay[3], 0, channel_data_size);
786
        case AC3_CHMODE_3F:
787
            memcpy(s->delay[2], s->delay[1], channel_data_size);
788
            memset(s->delay[1], 0, channel_data_size);
789
            break;
790
    }
791
}
792

    
793
/**
794
 * Parse an audio block from AC-3 bitstream.
795
 */
796
static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)
797
{
798
    int fbw_channels = s->fbw_channels;
799
    int channel_mode = s->channel_mode;
800
    int i, bnd, seg, ch;
801
    int different_transforms;
802
    int downmix_output;
803
    GetBitContext *gbc = &s->gbc;
804
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
805

    
806
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
807

    
808
    /* block switch flags */
809
    different_transforms = 0;
810
    for (ch = 1; ch <= fbw_channels; ch++) {
811
        s->block_switch[ch] = get_bits1(gbc);
812
        if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
813
            different_transforms = 1;
814
    }
815

    
816
    /* dithering flags */
817
    s->dither_all = 1;
818
    for (ch = 1; ch <= fbw_channels; ch++) {
819
        s->dither_flag[ch] = get_bits1(gbc);
820
        if(!s->dither_flag[ch])
821
            s->dither_all = 0;
822
    }
823

    
824
    /* dynamic range */
825
    i = !(s->channel_mode);
826
    do {
827
        if(get_bits1(gbc)) {
828
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
829
                                  s->avctx->drc_scale)+1.0;
830
        } else if(blk == 0) {
831
            s->dynamic_range[i] = 1.0f;
832
        }
833
    } while(i--);
834

    
835
    /* coupling strategy */
836
    if (get_bits1(gbc)) {
837
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
838
        s->cpl_in_use = get_bits1(gbc);
839
        if (s->cpl_in_use) {
840
            /* coupling in use */
841
            int cpl_begin_freq, cpl_end_freq;
842

    
843
            /* determine which channels are coupled */
844
            for (ch = 1; ch <= fbw_channels; ch++)
845
                s->channel_in_cpl[ch] = get_bits1(gbc);
846

    
847
            /* phase flags in use */
848
            if (channel_mode == AC3_CHMODE_STEREO)
849
                s->phase_flags_in_use = get_bits1(gbc);
850

    
851
            /* coupling frequency range and band structure */
852
            cpl_begin_freq = get_bits(gbc, 4);
853
            cpl_end_freq = get_bits(gbc, 4);
854
            if (3 + cpl_end_freq - cpl_begin_freq < 0) {
855
                av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
856
                return -1;
857
            }
858
            s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
859
            s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
860
            s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
861
            for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
862
                if (get_bits1(gbc)) {
863
                    s->cpl_band_struct[bnd] = 1;
864
                    s->num_cpl_bands--;
865
                }
866
            }
867
            s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
868
        } else {
869
            /* coupling not in use */
870
            for (ch = 1; ch <= fbw_channels; ch++)
871
                s->channel_in_cpl[ch] = 0;
872
        }
873
    }
874

    
875
    /* coupling coordinates */
876
    if (s->cpl_in_use) {
877
        int cpl_coords_exist = 0;
878

    
879
        for (ch = 1; ch <= fbw_channels; ch++) {
880
            if (s->channel_in_cpl[ch]) {
881
                if (get_bits1(gbc)) {
882
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
883
                    cpl_coords_exist = 1;
884
                    master_cpl_coord = 3 * get_bits(gbc, 2);
885
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
886
                        cpl_coord_exp = get_bits(gbc, 4);
887
                        cpl_coord_mant = get_bits(gbc, 4);
888
                        if (cpl_coord_exp == 15)
889
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
890
                        else
891
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
892
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
893
                    }
894
                }
895
            }
896
        }
897
        /* phase flags */
898
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
899
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
900
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
901
            }
902
        }
903
    }
904

    
905
    /* stereo rematrixing strategy and band structure */
906
    if (channel_mode == AC3_CHMODE_STEREO) {
907
        if (get_bits1(gbc)) {
908
            s->num_rematrixing_bands = 4;
909
            if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)
910
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
911
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
912
                s->rematrixing_flags[bnd] = get_bits1(gbc);
913
        }
914
    }
915

    
916
    /* exponent strategies for each channel */
917
    s->exp_strategy[CPL_CH] = EXP_REUSE;
918
    s->exp_strategy[s->lfe_ch] = EXP_REUSE;
919
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
920
        if(ch == s->lfe_ch)
921
            s->exp_strategy[ch] = get_bits(gbc, 1);
922
        else
923
            s->exp_strategy[ch] = get_bits(gbc, 2);
924
        if(s->exp_strategy[ch] != EXP_REUSE)
925
            bit_alloc_stages[ch] = 3;
926
    }
927

    
928
    /* channel bandwidth */
929
    for (ch = 1; ch <= fbw_channels; ch++) {
930
        s->start_freq[ch] = 0;
931
        if (s->exp_strategy[ch] != EXP_REUSE) {
932
            int prev = s->end_freq[ch];
933
            if (s->channel_in_cpl[ch])
934
                s->end_freq[ch] = s->start_freq[CPL_CH];
935
            else {
936
                int bandwidth_code = get_bits(gbc, 6);
937
                if (bandwidth_code > 60) {
938
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
939
                    return -1;
940
                }
941
                s->end_freq[ch] = bandwidth_code * 3 + 73;
942
            }
943
            if(blk > 0 && s->end_freq[ch] != prev)
944
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
945
        }
946
    }
947
    s->start_freq[s->lfe_ch] = 0;
948
    s->end_freq[s->lfe_ch] = 7;
949

    
950
    /* decode exponents for each channel */
951
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
952
        if (s->exp_strategy[ch] != EXP_REUSE) {
953
            int group_size, num_groups;
954
            group_size = 3 << (s->exp_strategy[ch] - 1);
955
            if(ch == CPL_CH)
956
                num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size;
957
            else if(ch == s->lfe_ch)
958
                num_groups = 2;
959
            else
960
                num_groups = (s->end_freq[ch] + group_size - 4) / group_size;
961
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
962
            decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0],
963
                             &s->dexps[ch][s->start_freq[ch]+!!ch]);
964
            if(ch != CPL_CH && ch != s->lfe_ch)
965
                skip_bits(gbc, 2); /* skip gainrng */
966
        }
967
    }
968

    
969
    /* bit allocation information */
970
    if (get_bits1(gbc)) {
971
        s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
972
        s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
973
        s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
974
        s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
975
        s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
976
        for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
977
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
978
        }
979
    }
980

    
981
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
982
    if (get_bits1(gbc)) {
983
        int csnr;
984
        csnr = (get_bits(gbc, 6) - 15) << 4;
985
        for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
986
            s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
987
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
988
        }
989
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
990
    }
991

    
992
    /* coupling leak information */
993
    if (s->cpl_in_use && get_bits1(gbc)) {
994
        s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
995
        s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
996
        bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
997
    }
998

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

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

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

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

    
1069
    /* recover coefficients if rematrixing is in use */
1070
    if(s->channel_mode == AC3_CHMODE_STEREO)
1071
        do_rematrixing(s);
1072

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

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

    
1100
        do_imdct(s, s->channels);
1101

    
1102
        if(downmix_output) {
1103
            ac3_downmix(s, s->output, 0);
1104
        }
1105
    } else {
1106
        if(downmix_output) {
1107
            ac3_downmix(s, s->transform_coeffs, 1);
1108
        }
1109

    
1110
        if(!s->downmixed) {
1111
            s->downmixed = 1;
1112
            ac3_downmix(s, s->delay, 0);
1113
        }
1114

    
1115
        do_imdct(s, s->out_channels);
1116
    }
1117

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

    
1126
    return 0;
1127
}
1128

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

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

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

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

    
1181
    /* check for crc mismatch */
1182
    if(avctx->error_resilience >= FF_ER_CAREFUL) {
1183
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1184
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1185
            return -1;
1186
        }
1187
        /* TODO: error concealment */
1188
    }
1189

    
1190
    avctx->sample_rate = s->sample_rate;
1191
    avctx->bit_rate = s->bit_rate;
1192

    
1193
    /* channel config */
1194
    s->out_channels = s->channels;
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

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

    
1223
/**
1224
 * Uninitialize the AC-3 decoder.
1225
 */
1226
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1227
{
1228
    AC3DecodeContext *s = avctx->priv_data;
1229
    ff_mdct_end(&s->imdct_512);
1230
    ff_mdct_end(&s->imdct_256);
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
};