Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ ec0350c9

History | View | Annotate | Download (39.5 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 <justin.ruggles@gmail.com>
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 "avcodec.h"
37
#include "ac3_parser.h"
38
#include "bitstream.h"
39
#include "dsputil.h"
40
#include "ac3dec.h"
41
#include "ac3dec_data.h"
42

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

    
46
/**
47
 * table for ungrouping 3 values in 7 bits.
48
 * used for exponents and bap=2 mantissas
49
 */
50
static uint8_t ungroup_3_in_7_bits_tab[128][3];
51

    
52

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

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

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

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

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

    
95
/**
96
 * Table for center mix levels
97
 * reference: Section 5.4.2.4 cmixlev
98
 */
99
static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
100

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

    
107
/**
108
 * Table for default stereo downmixing coefficients
109
 * reference: Section 7.8.2 Downmixing Into Two Channels
110
 */
111
static const uint8_t ac3_default_coeffs[8][5][2] = {
112
    { { 2, 7 }, { 7, 2 },                               },
113
    { { 4, 4 },                                         },
114
    { { 2, 7 }, { 7, 2 },                               },
115
    { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
116
    { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
117
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
118
    { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
119
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
120
};
121

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

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

    
140
    /* generate table for ungrouping 3 values in 7 bits
141
       reference: Section 7.1.3 Exponent Decoding */
142
    for(i=0; i<128; i++) {
143
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
144
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
145
        ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
146
    }
147

    
148
    /* generate grouped mantissa tables
149
       reference: Section 7.3.5 Ungrouping of Mantissas */
150
    for(i=0; i<32; i++) {
151
        /* bap=1 mantissas */
152
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
153
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
154
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
155
    }
156
    for(i=0; i<128; i++) {
157
        /* bap=2 mantissas */
158
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
159
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
160
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
161

    
162
        /* bap=4 mantissas */
163
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
164
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
165
    }
166
    /* generate ungrouped mantissa tables
167
       reference: Tables 7.21 and 7.23 */
168
    for(i=0; i<7; i++) {
169
        /* bap=3 mantissas */
170
        b3_mantissas[i] = symmetric_dequant(i, 7);
171
    }
172
    for(i=0; i<15; i++) {
173
        /* bap=5 mantissas */
174
        b5_mantissas[i] = symmetric_dequant(i, 15);
175
    }
176

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

    
185

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

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

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

    
211
    /* allow downmixing to stereo or mono */
212
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
213
            avctx->request_channels < avctx->channels &&
214
            avctx->request_channels <= 2) {
215
        avctx->channels = avctx->request_channels;
216
    }
217
    s->downmixed = 1;
218

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

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

    
230
/**
231
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
232
 * GetBitContext within AC3DecodeContext must point to
233
 * the start of the synchronized AC-3 bitstream.
234
 */
235
static int ac3_parse_header(AC3DecodeContext *s)
236
{
237
    GetBitContext *gbc = &s->gbc;
238
    int i;
239

    
240
    /* read the rest of the bsi. read twice for dual mono mode. */
241
    i = !(s->channel_mode);
242
    do {
243
        skip_bits(gbc, 5); // skip dialog normalization
244
        if (get_bits1(gbc))
245
            skip_bits(gbc, 8); //skip compression
246
        if (get_bits1(gbc))
247
            skip_bits(gbc, 8); //skip language code
248
        if (get_bits1(gbc))
249
            skip_bits(gbc, 7); //skip audio production information
250
    } while (i--);
251

    
252
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
253

    
254
    /* skip the timecodes (or extra bitstream information for Alternate Syntax)
255
       TODO: read & use the xbsi1 downmix levels */
256
    if (get_bits1(gbc))
257
        skip_bits(gbc, 14); //skip timecode1 / xbsi1
258
    if (get_bits1(gbc))
259
        skip_bits(gbc, 14); //skip timecode2 / xbsi2
260

    
261
    /* skip additional bitstream info */
262
    if (get_bits1(gbc)) {
263
        i = get_bits(gbc, 6);
264
        do {
265
            skip_bits(gbc, 8);
266
        } while(i--);
267
    }
268

    
269
    return 0;
270
}
271

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

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

    
284
    /* get decoding parameters from header info */
285
    s->bit_alloc_params.sr_code     = hdr.sr_code;
286
    s->channel_mode                 = hdr.channel_mode;
287
    s->lfe_on                       = hdr.lfe_on;
288
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
289
    s->sample_rate                  = hdr.sample_rate;
290
    s->bit_rate                     = hdr.bit_rate;
291
    s->channels                     = hdr.channels;
292
    s->fbw_channels                 = s->channels - s->lfe_on;
293
    s->lfe_ch                       = s->fbw_channels + 1;
294
    s->frame_size                   = hdr.frame_size;
295
    s->center_mix_level             = hdr.center_mix_level;
296
    s->surround_mix_level           = hdr.surround_mix_level;
297
    s->num_blocks                   = hdr.num_blocks;
298
    s->frame_type                   = hdr.frame_type;
299
    s->substreamid                  = hdr.substreamid;
300

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

    
308
    if(hdr.bitstream_id > 10)
309
        return AC3_PARSE_ERROR_BSID;
310

    
311
    return ac3_parse_header(s);
312
}
313

    
314
/**
315
 * Set stereo downmixing coefficients based on frame header info.
316
 * reference: Section 7.8.2 Downmixing Into Two Channels
317
 */
318
static void set_downmix_coeffs(AC3DecodeContext *s)
319
{
320
    int i;
321
    float cmix = gain_levels[center_levels[s->center_mix_level]];
322
    float smix = gain_levels[surround_levels[s->surround_mix_level]];
323
    float norm0, norm1;
324

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

    
341
    /* renormalize */
342
    norm0 = norm1 = 0.0;
343
    for(i=0; i<s->fbw_channels; i++) {
344
        norm0 += s->downmix_coeffs[i][0];
345
        norm1 += s->downmix_coeffs[i][1];
346
    }
347
    norm0 = 1.0f / norm0;
348
    norm1 = 1.0f / norm1;
349
    for(i=0; i<s->fbw_channels; i++) {
350
        s->downmix_coeffs[i][0] *= norm0;
351
        s->downmix_coeffs[i][1] *= norm1;
352
    }
353

    
354
    if(s->output_mode == AC3_CHMODE_MONO) {
355
        for(i=0; i<s->fbw_channels; i++)
356
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
357
    }
358
}
359

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

    
371
    /* unpack groups */
372
    group_size = exp_strategy + (exp_strategy == EXP_D45);
373
    for(grp=0,i=0; grp<ngrps; grp++) {
374
        expacc = get_bits(gbc, 7);
375
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
376
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
377
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
378
    }
379

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

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

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

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

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

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

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

    
455
            case 1:
456
                if(m->b1ptr > 2) {
457
                    gcode = get_bits(gbc, 5);
458
                    m->b1_mant[0] = b1_mantissas[gcode][0];
459
                    m->b1_mant[1] = b1_mantissas[gcode][1];
460
                    m->b1_mant[2] = b1_mantissas[gcode][2];
461
                    m->b1ptr = 0;
462
                }
463
                coeffs[i] = m->b1_mant[m->b1ptr++];
464
                break;
465

    
466
            case 2:
467
                if(m->b2ptr > 2) {
468
                    gcode = get_bits(gbc, 7);
469
                    m->b2_mant[0] = b2_mantissas[gcode][0];
470
                    m->b2_mant[1] = b2_mantissas[gcode][1];
471
                    m->b2_mant[2] = b2_mantissas[gcode][2];
472
                    m->b2ptr = 0;
473
                }
474
                coeffs[i] = m->b2_mant[m->b2ptr++];
475
                break;
476

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

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

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

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

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

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

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

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

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

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

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

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

    
587
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
588
        if(s->rematrixing_flags[bnd]) {
589
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
590
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
591
                tmp0 = s->fixed_coeffs[1][i];
592
                tmp1 = s->fixed_coeffs[2][i];
593
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
594
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
595
            }
596
        }
597
    }
598
}
599

    
600
/**
601
 * Inverse MDCT Transform.
602
 * Convert frequency domain coefficients to time-domain audio samples.
603
 * reference: Section 7.9.4 Transformation Equations
604
 */
605
static inline void do_imdct(AC3DecodeContext *s, int channels)
606
{
607
    int ch;
608
    float add_bias = s->add_bias;
609
    if(s->out_channels==1 && channels>1)
610
        add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
611

    
612
    for (ch=1; ch<=channels; ch++) {
613
        if (s->block_switch[ch]) {
614
            int i;
615
            float *x = s->tmp_output+128;
616
            for(i=0; i<128; i++)
617
                x[i] = s->transform_coeffs[ch][2*i];
618
            ff_imdct_half(&s->imdct_256, s->tmp_output, x);
619
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
620
            for(i=0; i<128; i++)
621
                x[i] = s->transform_coeffs[ch][2*i+1];
622
            ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
623
        } else {
624
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
625
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
626
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
627
        }
628
    }
629
}
630

    
631
/**
632
 * Downmix the output to mono or stereo.
633
 */
634
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
635
{
636
    int i, j;
637
    float v0, v1;
638
    if(out_ch == 2) {
639
        for(i=0; i<len; i++) {
640
            v0 = v1 = 0.0f;
641
            for(j=0; j<in_ch; j++) {
642
                v0 += samples[j][i] * matrix[j][0];
643
                v1 += samples[j][i] * matrix[j][1];
644
            }
645
            samples[0][i] = v0;
646
            samples[1][i] = v1;
647
        }
648
    } else if(out_ch == 1) {
649
        for(i=0; i<len; i++) {
650
            v0 = 0.0f;
651
            for(j=0; j<in_ch; j++)
652
                v0 += samples[j][i] * matrix[j][0];
653
            samples[0][i] = v0;
654
        }
655
    }
656
}
657

    
658
/**
659
 * Upmix delay samples from stereo to original channel layout.
660
 */
661
static void ac3_upmix_delay(AC3DecodeContext *s)
662
{
663
    int channel_data_size = 128*sizeof(float);
664
    switch(s->channel_mode) {
665
        case AC3_CHMODE_DUALMONO:
666
        case AC3_CHMODE_STEREO:
667
            /* upmix mono to stereo */
668
            memcpy(s->delay[1], s->delay[0], channel_data_size);
669
            break;
670
        case AC3_CHMODE_2F2R:
671
            memset(s->delay[3], 0, channel_data_size);
672
        case AC3_CHMODE_2F1R:
673
            memset(s->delay[2], 0, channel_data_size);
674
            break;
675
        case AC3_CHMODE_3F2R:
676
            memset(s->delay[4], 0, channel_data_size);
677
        case AC3_CHMODE_3F1R:
678
            memset(s->delay[3], 0, channel_data_size);
679
        case AC3_CHMODE_3F:
680
            memcpy(s->delay[2], s->delay[1], channel_data_size);
681
            memset(s->delay[1], 0, channel_data_size);
682
            break;
683
    }
684
}
685

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

    
700
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
701

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
915
    /* delta bit allocation information */
916
    if (get_bits1(gbc)) {
917
        /* delta bit allocation exists (strategy) */
918
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
919
            s->dba_mode[ch] = get_bits(gbc, 2);
920
            if (s->dba_mode[ch] == DBA_RESERVED) {
921
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
922
                return -1;
923
            }
924
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
925
        }
926
        /* channel delta offset, len and bit allocation */
927
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
928
            if (s->dba_mode[ch] == DBA_NEW) {
929
                s->dba_nsegs[ch] = get_bits(gbc, 3);
930
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
931
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
932
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
933
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
934
                }
935
                /* run last 2 bit allocation stages if new dba values */
936
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
937
            }
938
        }
939
    } else if(blk == 0) {
940
        for(ch=0; ch<=s->channels; ch++) {
941
            s->dba_mode[ch] = DBA_NONE;
942
        }
943
    }
944

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

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

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

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

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

    
999
    /* downmix and MDCT. order depends on whether block switching is used for
1000
       any channel in this block. this is because coefficients for the long
1001
       and short transforms cannot be mixed. */
1002
    downmix_output = s->channels != s->out_channels &&
1003
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1004
                     s->fbw_channels == s->out_channels);
1005
    if(different_transforms) {
1006
        /* the delay samples have already been downmixed, so we upmix the delay
1007
           samples in order to reconstruct all channels before downmixing. */
1008
        if(s->downmixed) {
1009
            s->downmixed = 0;
1010
            ac3_upmix_delay(s);
1011
        }
1012

    
1013
        do_imdct(s, s->channels);
1014

    
1015
        if(downmix_output) {
1016
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1017
        }
1018
    } else {
1019
        if(downmix_output) {
1020
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1021
        }
1022

    
1023
        if(downmix_output && !s->downmixed) {
1024
            s->downmixed = 1;
1025
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1026
        }
1027

    
1028
        do_imdct(s, s->out_channels);
1029
    }
1030

    
1031
    return 0;
1032
}
1033

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

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

    
1054
    /* parse the syncinfo */
1055
    *data_size = 0;
1056
    err = parse_frame_header(s);
1057

    
1058
    /* check that reported frame size fits in input buffer */
1059
    if(s->frame_size > buf_size) {
1060
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1061
        err = AC3_PARSE_ERROR_FRAME_SIZE;
1062
    }
1063

    
1064
    /* check for crc mismatch */
1065
    if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1066
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1067
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1068
            err = AC3_PARSE_ERROR_CRC;
1069
        }
1070
    }
1071

    
1072
    if(err && err != AC3_PARSE_ERROR_CRC) {
1073
        switch(err) {
1074
            case AC3_PARSE_ERROR_SYNC:
1075
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1076
                return -1;
1077
            case AC3_PARSE_ERROR_BSID:
1078
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1079
                break;
1080
            case AC3_PARSE_ERROR_SAMPLE_RATE:
1081
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1082
                break;
1083
            case AC3_PARSE_ERROR_FRAME_SIZE:
1084
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1085
                break;
1086
            case AC3_PARSE_ERROR_FRAME_TYPE:
1087
                /* skip frame if CRC is ok. otherwise use error concealment. */
1088
                /* TODO: add support for substreams and dependent frames */
1089
                if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1090
                    av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1091
                    return s->frame_size;
1092
                } else {
1093
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1094
                }
1095
                break;
1096
            default:
1097
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1098
                break;
1099
        }
1100
    }
1101

    
1102
    /* if frame is ok, set audio parameters */
1103
    if (!err) {
1104
        avctx->sample_rate = s->sample_rate;
1105
        avctx->bit_rate = s->bit_rate;
1106

    
1107
        /* channel config */
1108
        s->out_channels = s->channels;
1109
        s->output_mode = s->channel_mode;
1110
        if(s->lfe_on)
1111
            s->output_mode |= AC3_OUTPUT_LFEON;
1112
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1113
                avctx->request_channels < s->channels) {
1114
            s->out_channels = avctx->request_channels;
1115
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1116
        }
1117
        avctx->channels = s->out_channels;
1118

    
1119
        /* set downmixing coefficients if needed */
1120
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1121
                s->fbw_channels == s->out_channels)) {
1122
            set_downmix_coeffs(s);
1123
        }
1124
    } else if (!s->out_channels) {
1125
        s->out_channels = avctx->channels;
1126
        if(s->out_channels < s->channels)
1127
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1128
    }
1129

    
1130
    /* decode the audio blocks */
1131
    for (blk = 0; blk < s->num_blocks; blk++) {
1132
        const float *output[s->out_channels];
1133
        if (!err && decode_audio_block(s, blk)) {
1134
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1135
        }
1136
        for (ch = 0; ch < s->out_channels; ch++)
1137
            output[ch] = s->output[ch];
1138
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1139
        out_samples += 256 * s->out_channels;
1140
    }
1141
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1142
    return s->frame_size;
1143
}
1144

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

    
1154
    av_freep(&s->input_buffer);
1155

    
1156
    return 0;
1157
}
1158

    
1159
AVCodec ac3_decoder = {
1160
    .name = "ac3",
1161
    .type = CODEC_TYPE_AUDIO,
1162
    .id = CODEC_ID_AC3,
1163
    .priv_data_size = sizeof (AC3DecodeContext),
1164
    .init = ac3_decode_init,
1165
    .close = ac3_decode_end,
1166
    .decode = ac3_decode_frame,
1167
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 / AC-3"),
1168
};