Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 911e21a3

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
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
    float norm0, norm1;
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
701
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
702

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1032
    return 0;
1033
}
1034

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

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

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

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

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

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

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

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

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

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

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

    
1155
    av_freep(&s->input_buffer);
1156

    
1157
    return 0;
1158
}
1159

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