Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 72745cff

History | View | Annotate | Download (39.2 KB)

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

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

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

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

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

    
53

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
186

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

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

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

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

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

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

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

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

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

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

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

    
270
    return 0;
271
}
272

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

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

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

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

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

    
312
    return ac3_parse_header(s);
313
}
314

    
315
/**
316
 * Set stereo downmixing coefficients based on frame header info.
317
 * reference: Section 7.8.2 Downmixing Into Two Channels
318
 */
319
static void set_downmix_coeffs(AC3DecodeContext *s)
320
{
321
    int i;
322
    float cmix = gain_levels[center_levels[s->center_mix_level]];
323
    float smix = gain_levels[surround_levels[s->surround_mix_level]];
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
    /* calculate adjustment needed for each channel to avoid clipping */
342
    s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
343
    for(i=0; i<s->fbw_channels; i++) {
344
        s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
345
        s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
346
    }
347
    s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
348
    s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
349
}
350

    
351
/**
352
 * Decode the grouped exponents according to exponent strategy.
353
 * reference: Section 7.1.3 Exponent Decoding
354
 */
355
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
356
                             uint8_t absexp, int8_t *dexps)
357
{
358
    int i, j, grp, group_size;
359
    int dexp[256];
360
    int expacc, prevexp;
361

    
362
    /* unpack groups */
363
    group_size = exp_strategy + (exp_strategy == EXP_D45);
364
    for(grp=0,i=0; grp<ngrps; grp++) {
365
        expacc = get_bits(gbc, 7);
366
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
367
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
368
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
369
    }
370

    
371
    /* convert to absolute exps and expand groups */
372
    prevexp = absexp;
373
    for(i=0; i<ngrps*3; i++) {
374
        prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
375
        for(j=0; j<group_size; j++) {
376
            dexps[(i*group_size)+j] = prevexp;
377
        }
378
    }
379
}
380

    
381
/**
382
 * Generate transform coefficients for each coupled channel in the coupling
383
 * range using the coupling coefficients and coupling coordinates.
384
 * reference: Section 7.4.3 Coupling Coordinate Format
385
 */
386
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
387
{
388
    int i, j, ch, bnd, subbnd;
389

    
390
    subbnd = -1;
391
    i = s->start_freq[CPL_CH];
392
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
393
        do {
394
            subbnd++;
395
            for(j=0; j<12; j++) {
396
                for(ch=1; ch<=s->fbw_channels; ch++) {
397
                    if(s->channel_in_cpl[ch]) {
398
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
399
                        if (ch == 2 && s->phase_flags[bnd])
400
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
401
                    }
402
                }
403
                i++;
404
            }
405
        } while(s->cpl_band_struct[subbnd]);
406
    }
407
}
408

    
409
/**
410
 * Grouped mantissas for 3-level 5-level and 11-level quantization
411
 */
412
typedef struct {
413
    int b1_mant[3];
414
    int b2_mant[3];
415
    int b4_mant[2];
416
    int b1ptr;
417
    int b2ptr;
418
    int b4ptr;
419
} mant_groups;
420

    
421
/**
422
 * Get the transform coefficients for a particular channel
423
 * reference: Section 7.3 Quantization and Decoding of Mantissas
424
 */
425
static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
426
{
427
    GetBitContext *gbc = &s->gbc;
428
    int i, gcode, tbap, start, end;
429
    uint8_t *exps;
430
    uint8_t *bap;
431
    int *coeffs;
432

    
433
    exps = s->dexps[ch_index];
434
    bap = s->bap[ch_index];
435
    coeffs = s->fixed_coeffs[ch_index];
436
    start = s->start_freq[ch_index];
437
    end = s->end_freq[ch_index];
438

    
439
    for (i = start; i < end; i++) {
440
        tbap = bap[i];
441
        switch (tbap) {
442
            case 0:
443
                coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 0x400000;
444
                break;
445

    
446
            case 1:
447
                if(m->b1ptr > 2) {
448
                    gcode = get_bits(gbc, 5);
449
                    m->b1_mant[0] = b1_mantissas[gcode][0];
450
                    m->b1_mant[1] = b1_mantissas[gcode][1];
451
                    m->b1_mant[2] = b1_mantissas[gcode][2];
452
                    m->b1ptr = 0;
453
                }
454
                coeffs[i] = m->b1_mant[m->b1ptr++];
455
                break;
456

    
457
            case 2:
458
                if(m->b2ptr > 2) {
459
                    gcode = get_bits(gbc, 7);
460
                    m->b2_mant[0] = b2_mantissas[gcode][0];
461
                    m->b2_mant[1] = b2_mantissas[gcode][1];
462
                    m->b2_mant[2] = b2_mantissas[gcode][2];
463
                    m->b2ptr = 0;
464
                }
465
                coeffs[i] = m->b2_mant[m->b2ptr++];
466
                break;
467

    
468
            case 3:
469
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
470
                break;
471

    
472
            case 4:
473
                if(m->b4ptr > 1) {
474
                    gcode = get_bits(gbc, 7);
475
                    m->b4_mant[0] = b4_mantissas[gcode][0];
476
                    m->b4_mant[1] = b4_mantissas[gcode][1];
477
                    m->b4ptr = 0;
478
                }
479
                coeffs[i] = m->b4_mant[m->b4ptr++];
480
                break;
481

    
482
            case 5:
483
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
484
                break;
485

    
486
            default: {
487
                /* asymmetric dequantization */
488
                int qlevel = quantization_tab[tbap];
489
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
490
                break;
491
            }
492
        }
493
        coeffs[i] >>= exps[i];
494
    }
495
}
496

    
497
/**
498
 * Remove random dithering from coefficients with zero-bit mantissas
499
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
500
 */
501
static void remove_dithering(AC3DecodeContext *s) {
502
    int ch, i;
503
    int end=0;
504
    int *coeffs;
505
    uint8_t *bap;
506

    
507
    for(ch=1; ch<=s->fbw_channels; ch++) {
508
        if(!s->dither_flag[ch]) {
509
            coeffs = s->fixed_coeffs[ch];
510
            bap = s->bap[ch];
511
            if(s->channel_in_cpl[ch])
512
                end = s->start_freq[CPL_CH];
513
            else
514
                end = s->end_freq[ch];
515
            for(i=0; i<end; i++) {
516
                if(!bap[i])
517
                    coeffs[i] = 0;
518
            }
519
            if(s->channel_in_cpl[ch]) {
520
                bap = s->bap[CPL_CH];
521
                for(; i<s->end_freq[CPL_CH]; i++) {
522
                    if(!bap[i])
523
                        coeffs[i] = 0;
524
                }
525
            }
526
        }
527
    }
528
}
529

    
530
/**
531
 * Get the transform coefficients.
532
 */
533
static void get_transform_coeffs(AC3DecodeContext *s)
534
{
535
    int ch, end;
536
    int got_cplchan = 0;
537
    mant_groups m;
538

    
539
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
540

    
541
    for (ch = 1; ch <= s->channels; ch++) {
542
        /* transform coefficients for full-bandwidth channel */
543
        get_transform_coeffs_ch(s, ch, &m);
544
        /* tranform coefficients for coupling channel come right after the
545
           coefficients for the first coupled channel*/
546
        if (s->channel_in_cpl[ch])  {
547
            if (!got_cplchan) {
548
                get_transform_coeffs_ch(s, CPL_CH, &m);
549
                calc_transform_coeffs_cpl(s);
550
                got_cplchan = 1;
551
            }
552
            end = s->end_freq[CPL_CH];
553
        } else {
554
            end = s->end_freq[ch];
555
        }
556
        do
557
            s->fixed_coeffs[ch][end] = 0;
558
        while(++end < 256);
559
    }
560

    
561
    /* if any channel doesn't use dithering, zero appropriate coefficients */
562
    if(!s->dither_all)
563
        remove_dithering(s);
564
}
565

    
566
/**
567
 * Stereo rematrixing.
568
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
569
 */
570
static void do_rematrixing(AC3DecodeContext *s)
571
{
572
    int bnd, i;
573
    int end, bndend;
574
    int tmp0, tmp1;
575

    
576
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
577

    
578
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
579
        if(s->rematrixing_flags[bnd]) {
580
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
581
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
582
                tmp0 = s->fixed_coeffs[1][i];
583
                tmp1 = s->fixed_coeffs[2][i];
584
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
585
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
586
            }
587
        }
588
    }
589
}
590

    
591
/**
592
 * Inverse MDCT Transform.
593
 * Convert frequency domain coefficients to time-domain audio samples.
594
 * reference: Section 7.9.4 Transformation Equations
595
 */
596
static inline void do_imdct(AC3DecodeContext *s, int channels)
597
{
598
    int ch;
599

    
600
    for (ch=1; ch<=channels; ch++) {
601
        if (s->block_switch[ch]) {
602
            int i;
603
            float *x = s->tmp_output+128;
604
            for(i=0; i<128; i++)
605
                x[i] = s->transform_coeffs[ch][2*i];
606
            ff_imdct_half(&s->imdct_256, s->tmp_output, x);
607
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, s->add_bias, 128);
608
            for(i=0; i<128; i++)
609
                x[i] = s->transform_coeffs[ch][2*i+1];
610
            ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
611
        } else {
612
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
613
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, s->add_bias, 128);
614
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
615
        }
616
    }
617
}
618

    
619
/**
620
 * Downmix the output to mono or stereo.
621
 */
622
static void ac3_downmix(AC3DecodeContext *s,
623
                        float samples[AC3_MAX_CHANNELS][256], int ch_offset)
624
{
625
    int i, j;
626
    float v0, v1;
627

    
628
    for(i=0; i<256; i++) {
629
        v0 = v1 = 0.0f;
630
        for(j=0; j<s->fbw_channels; j++) {
631
            v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
632
            v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
633
        }
634
        v0 *= s->downmix_coeff_adjust[0];
635
        v1 *= s->downmix_coeff_adjust[1];
636
        if(s->output_mode == AC3_CHMODE_MONO) {
637
            samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
638
        } else if(s->output_mode == AC3_CHMODE_STEREO) {
639
            samples[  ch_offset][i] = v0;
640
            samples[1+ch_offset][i] = v1;
641
        }
642
    }
643
}
644

    
645
/**
646
 * Upmix delay samples from stereo to original channel layout.
647
 */
648
static void ac3_upmix_delay(AC3DecodeContext *s)
649
{
650
    int channel_data_size = 128*sizeof(float);
651
    switch(s->channel_mode) {
652
        case AC3_CHMODE_DUALMONO:
653
        case AC3_CHMODE_STEREO:
654
            /* upmix mono to stereo */
655
            memcpy(s->delay[1], s->delay[0], channel_data_size);
656
            break;
657
        case AC3_CHMODE_2F2R:
658
            memset(s->delay[3], 0, channel_data_size);
659
        case AC3_CHMODE_2F1R:
660
            memset(s->delay[2], 0, channel_data_size);
661
            break;
662
        case AC3_CHMODE_3F2R:
663
            memset(s->delay[4], 0, channel_data_size);
664
        case AC3_CHMODE_3F1R:
665
            memset(s->delay[3], 0, channel_data_size);
666
        case AC3_CHMODE_3F:
667
            memcpy(s->delay[2], s->delay[1], channel_data_size);
668
            memset(s->delay[1], 0, channel_data_size);
669
            break;
670
    }
671
}
672

    
673
/**
674
 * Decode a single audio block from the AC-3 bitstream.
675
 */
676
static int decode_audio_block(AC3DecodeContext *s, int blk)
677
{
678
    int fbw_channels = s->fbw_channels;
679
    int channel_mode = s->channel_mode;
680
    int i, bnd, seg, ch;
681
    int different_transforms;
682
    int downmix_output;
683
    int cpl_in_use;
684
    GetBitContext *gbc = &s->gbc;
685
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
686

    
687
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
688

    
689
    /* block switch flags */
690
    different_transforms = 0;
691
    for (ch = 1; ch <= fbw_channels; ch++) {
692
        s->block_switch[ch] = get_bits1(gbc);
693
        if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
694
            different_transforms = 1;
695
    }
696

    
697
    /* dithering flags */
698
    s->dither_all = 1;
699
    for (ch = 1; ch <= fbw_channels; ch++) {
700
        s->dither_flag[ch] = get_bits1(gbc);
701
        if(!s->dither_flag[ch])
702
            s->dither_all = 0;
703
    }
704

    
705
    /* dynamic range */
706
    i = !(s->channel_mode);
707
    do {
708
        if(get_bits1(gbc)) {
709
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
710
                                  s->avctx->drc_scale)+1.0;
711
        } else if(blk == 0) {
712
            s->dynamic_range[i] = 1.0f;
713
        }
714
    } while(i--);
715

    
716
    /* coupling strategy */
717
    if (get_bits1(gbc)) {
718
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
719
        s->cpl_in_use[blk] = get_bits1(gbc);
720
        if (s->cpl_in_use[blk]) {
721
            /* coupling in use */
722
            int cpl_begin_freq, cpl_end_freq;
723

    
724
            if (channel_mode < AC3_CHMODE_STEREO) {
725
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
726
                return -1;
727
            }
728

    
729
            /* determine which channels are coupled */
730
            for (ch = 1; ch <= fbw_channels; ch++)
731
                s->channel_in_cpl[ch] = get_bits1(gbc);
732

    
733
            /* phase flags in use */
734
            if (channel_mode == AC3_CHMODE_STEREO)
735
                s->phase_flags_in_use = get_bits1(gbc);
736

    
737
            /* coupling frequency range and band structure */
738
            cpl_begin_freq = get_bits(gbc, 4);
739
            cpl_end_freq = get_bits(gbc, 4);
740
            if (3 + cpl_end_freq - cpl_begin_freq < 0) {
741
                av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
742
                return -1;
743
            }
744
            s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
745
            s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
746
            s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
747
            for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
748
                if (get_bits1(gbc)) {
749
                    s->cpl_band_struct[bnd] = 1;
750
                    s->num_cpl_bands--;
751
                }
752
            }
753
            s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
754
        } else {
755
            /* coupling not in use */
756
            for (ch = 1; ch <= fbw_channels; ch++)
757
                s->channel_in_cpl[ch] = 0;
758
        }
759
    } else if (!blk) {
760
        av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
761
        return -1;
762
    } else {
763
        s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
764
    }
765
    cpl_in_use = s->cpl_in_use[blk];
766

    
767
    /* coupling coordinates */
768
    if (cpl_in_use) {
769
        int cpl_coords_exist = 0;
770

    
771
        for (ch = 1; ch <= fbw_channels; ch++) {
772
            if (s->channel_in_cpl[ch]) {
773
                if (get_bits1(gbc)) {
774
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
775
                    cpl_coords_exist = 1;
776
                    master_cpl_coord = 3 * get_bits(gbc, 2);
777
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
778
                        cpl_coord_exp = get_bits(gbc, 4);
779
                        cpl_coord_mant = get_bits(gbc, 4);
780
                        if (cpl_coord_exp == 15)
781
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
782
                        else
783
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
784
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
785
                    }
786
                } else if (!blk) {
787
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
788
                    return -1;
789
                }
790
            }
791
        }
792
        /* phase flags */
793
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
794
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
795
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
796
            }
797
        }
798
    }
799

    
800
    /* stereo rematrixing strategy and band structure */
801
    if (channel_mode == AC3_CHMODE_STEREO) {
802
        if (get_bits1(gbc)) {
803
            s->num_rematrixing_bands = 4;
804
            if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
805
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
806
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
807
                s->rematrixing_flags[bnd] = get_bits1(gbc);
808
        } else if (!blk) {
809
            av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
810
            return -1;
811
        }
812
    }
813

    
814
    /* exponent strategies for each channel */
815
    s->exp_strategy[blk][CPL_CH] = EXP_REUSE;
816
    s->exp_strategy[blk][s->lfe_ch] = EXP_REUSE;
817
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
818
        s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
819
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
820
            bit_alloc_stages[ch] = 3;
821
    }
822

    
823
    /* channel bandwidth */
824
    for (ch = 1; ch <= fbw_channels; ch++) {
825
        s->start_freq[ch] = 0;
826
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
827
            int group_size;
828
            int prev = s->end_freq[ch];
829
            if (s->channel_in_cpl[ch])
830
                s->end_freq[ch] = s->start_freq[CPL_CH];
831
            else {
832
                int bandwidth_code = get_bits(gbc, 6);
833
                if (bandwidth_code > 60) {
834
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
835
                    return -1;
836
                }
837
                s->end_freq[ch] = bandwidth_code * 3 + 73;
838
            }
839
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
840
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
841
            if(blk > 0 && s->end_freq[ch] != prev)
842
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
843
        }
844
    }
845
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
846
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
847
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
848
    }
849

    
850
    /* decode exponents for each channel */
851
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
852
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
853
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
854
            decode_exponents(gbc, s->exp_strategy[blk][ch],
855
                             s->num_exp_groups[ch], s->dexps[ch][0],
856
                             &s->dexps[ch][s->start_freq[ch]+!!ch]);
857
            if(ch != CPL_CH && ch != s->lfe_ch)
858
                skip_bits(gbc, 2); /* skip gainrng */
859
        }
860
    }
861

    
862
    /* bit allocation information */
863
    if (get_bits1(gbc)) {
864
        s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
865
        s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
866
        s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
867
        s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
868
        s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
869
        for(ch=!cpl_in_use; ch<=s->channels; ch++)
870
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
871
    } else if (!blk) {
872
        av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
873
        return -1;
874
    }
875

    
876
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
877
    if (get_bits1(gbc)) {
878
        int csnr;
879
        csnr = (get_bits(gbc, 6) - 15) << 4;
880
        for (ch = !cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
881
            s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
882
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
883
        }
884
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
885
    } else if (!blk) {
886
        av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
887
        return -1;
888
    }
889

    
890
    /* coupling leak information */
891
    if (cpl_in_use) {
892
        if (get_bits1(gbc)) {
893
            s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
894
            s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
895
            bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
896
        } else if (!blk) {
897
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
898
            return -1;
899
        }
900
    }
901

    
902
    /* delta bit allocation information */
903
    if (get_bits1(gbc)) {
904
        /* delta bit allocation exists (strategy) */
905
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
906
            s->dba_mode[ch] = get_bits(gbc, 2);
907
            if (s->dba_mode[ch] == DBA_RESERVED) {
908
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
909
                return -1;
910
            }
911
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
912
        }
913
        /* channel delta offset, len and bit allocation */
914
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
915
            if (s->dba_mode[ch] == DBA_NEW) {
916
                s->dba_nsegs[ch] = get_bits(gbc, 3);
917
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
918
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
919
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
920
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
921
                }
922
                /* run last 2 bit allocation stages if new dba values */
923
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
924
            }
925
        }
926
    } else if(blk == 0) {
927
        for(ch=0; ch<=s->channels; ch++) {
928
            s->dba_mode[ch] = DBA_NONE;
929
        }
930
    }
931

    
932
    /* Bit allocation */
933
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
934
        if(bit_alloc_stages[ch] > 2) {
935
            /* Exponent mapping into PSD and PSD integration */
936
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
937
                                      s->start_freq[ch], s->end_freq[ch],
938
                                      s->psd[ch], s->band_psd[ch]);
939
        }
940
        if(bit_alloc_stages[ch] > 1) {
941
            /* Compute excitation function, Compute masking curve, and
942
               Apply delta bit allocation */
943
            ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
944
                                       s->start_freq[ch], s->end_freq[ch],
945
                                       s->fast_gain[ch], (ch == s->lfe_ch),
946
                                       s->dba_mode[ch], s->dba_nsegs[ch],
947
                                       s->dba_offsets[ch], s->dba_lengths[ch],
948
                                       s->dba_values[ch], s->mask[ch]);
949
        }
950
        if(bit_alloc_stages[ch] > 0) {
951
            /* Compute bit allocation */
952
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
953
                                      s->start_freq[ch], s->end_freq[ch],
954
                                      s->snr_offset[ch],
955
                                      s->bit_alloc_params.floor,
956
                                      ff_ac3_bap_tab, s->bap[ch]);
957
        }
958
    }
959

    
960
    /* unused dummy data */
961
    if (get_bits1(gbc)) {
962
        int skipl = get_bits(gbc, 9);
963
        while(skipl--)
964
            skip_bits(gbc, 8);
965
    }
966

    
967
    /* unpack the transform coefficients
968
       this also uncouples channels if coupling is in use. */
969
    get_transform_coeffs(s);
970

    
971
    /* recover coefficients if rematrixing is in use */
972
    if(s->channel_mode == AC3_CHMODE_STEREO)
973
        do_rematrixing(s);
974

    
975
    /* apply scaling to coefficients (headroom, dynrng) */
976
    for(ch=1; ch<=s->channels; ch++) {
977
        float gain = s->mul_bias / 4194304.0f;
978
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
979
            gain *= s->dynamic_range[ch-1];
980
        } else {
981
            gain *= s->dynamic_range[0];
982
        }
983
        for(i=0; i<256; i++) {
984
            s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
985
        }
986
    }
987

    
988
    /* downmix and MDCT. order depends on whether block switching is used for
989
       any channel in this block. this is because coefficients for the long
990
       and short transforms cannot be mixed. */
991
    downmix_output = s->channels != s->out_channels &&
992
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
993
                     s->fbw_channels == s->out_channels);
994
    if(different_transforms) {
995
        /* the delay samples have already been downmixed, so we upmix the delay
996
           samples in order to reconstruct all channels before downmixing. */
997
        if(s->downmixed) {
998
            s->downmixed = 0;
999
            ac3_upmix_delay(s);
1000
        }
1001

    
1002
        do_imdct(s, s->channels);
1003

    
1004
        if(downmix_output) {
1005
            ac3_downmix(s, s->output, 0);
1006
        }
1007
    } else {
1008
        if(downmix_output) {
1009
            ac3_downmix(s, s->transform_coeffs, 1);
1010
        }
1011

    
1012
        if(!s->downmixed) {
1013
            s->downmixed = 1;
1014
            // FIXME delay[] is half the size of the other downmixes
1015
            ac3_downmix(s, s->delay, 0);
1016
        }
1017

    
1018
        do_imdct(s, s->out_channels);
1019
    }
1020

    
1021
    return 0;
1022
}
1023

    
1024
/**
1025
 * Decode a single AC-3 frame.
1026
 */
1027
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1028
                            const uint8_t *buf, int buf_size)
1029
{
1030
    AC3DecodeContext *s = avctx->priv_data;
1031
    int16_t *out_samples = (int16_t *)data;
1032
    int blk, ch, err;
1033

    
1034
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1035
    if (s->input_buffer) {
1036
        /* copy input buffer to decoder context to avoid reading past the end
1037
           of the buffer, which can be caused by a damaged input stream. */
1038
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1039
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1040
    } else {
1041
        init_get_bits(&s->gbc, buf, buf_size * 8);
1042
    }
1043

    
1044
    /* parse the syncinfo */
1045
    *data_size = 0;
1046
    err = parse_frame_header(s);
1047

    
1048
    /* check that reported frame size fits in input buffer */
1049
    if(s->frame_size > buf_size) {
1050
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1051
        err = AC3_PARSE_ERROR_FRAME_SIZE;
1052
    }
1053

    
1054
    /* check for crc mismatch */
1055
    if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1056
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1057
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1058
            err = AC3_PARSE_ERROR_CRC;
1059
        }
1060
    }
1061

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

    
1092
    /* if frame is ok, set audio parameters */
1093
    if (!err) {
1094
        avctx->sample_rate = s->sample_rate;
1095
        avctx->bit_rate = s->bit_rate;
1096

    
1097
        /* channel config */
1098
        s->out_channels = s->channels;
1099
        s->output_mode = s->channel_mode;
1100
        if(s->lfe_on)
1101
            s->output_mode |= AC3_OUTPUT_LFEON;
1102
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1103
                avctx->request_channels < s->channels) {
1104
            s->out_channels = avctx->request_channels;
1105
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1106
        }
1107
        avctx->channels = s->out_channels;
1108

    
1109
        /* set downmixing coefficients if needed */
1110
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1111
                s->fbw_channels == s->out_channels)) {
1112
            set_downmix_coeffs(s);
1113
        }
1114
    } else if (!s->out_channels) {
1115
        s->out_channels = avctx->channels;
1116
        if(s->out_channels < s->channels)
1117
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1118
    }
1119

    
1120
    /* decode the audio blocks */
1121
    for (blk = 0; blk < s->num_blocks; blk++) {
1122
        const float *output[s->out_channels];
1123
        if (!err && decode_audio_block(s, blk)) {
1124
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1125
        }
1126
        for (ch = 0; ch < s->out_channels; ch++)
1127
            output[ch] = s->output[ch];
1128
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1129
        out_samples += 256 * s->out_channels;
1130
    }
1131
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1132
    return s->frame_size;
1133
}
1134

    
1135
/**
1136
 * Uninitialize the AC-3 decoder.
1137
 */
1138
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1139
{
1140
    AC3DecodeContext *s = avctx->priv_data;
1141
    ff_mdct_end(&s->imdct_512);
1142
    ff_mdct_end(&s->imdct_256);
1143

    
1144
    av_freep(&s->input_buffer);
1145

    
1146
    return 0;
1147
}
1148

    
1149
AVCodec ac3_decoder = {
1150
    .name = "ac3",
1151
    .type = CODEC_TYPE_AUDIO,
1152
    .id = CODEC_ID_AC3,
1153
    .priv_data_size = sizeof (AC3DecodeContext),
1154
    .init = ac3_decode_init,
1155
    .close = ac3_decode_end,
1156
    .decode = ac3_decode_frame,
1157
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 / AC-3"),
1158
};