Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 6ee6d068

History | View | Annotate | Download (45 KB)

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

    
32
#include <stdio.h>
33
#include <stddef.h>
34
#include <math.h>
35
#include <string.h>
36

    
37
#include "libavutil/crc.h"
38
#include "ac3_parser.h"
39
#include "ac3dec.h"
40
#include "ac3dec_data.h"
41

    
42
/** Large enough for maximum possible frame size when the specification limit is ignored */
43
#define AC3_FRAME_BUFFER_SIZE 32768
44

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

    
51

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
184

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

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

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

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

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

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

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

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

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

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

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

    
268
    return 0;
269
}
270

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

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

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

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

    
307
    if (hdr.bitstream_id <= 10) {
308
        s->eac3                  = 0;
309
        s->snr_offset_strategy   = 2;
310
        s->block_switch_syntax   = 1;
311
        s->dither_flag_syntax    = 1;
312
        s->bit_allocation_syntax = 1;
313
        s->fast_gain_syntax      = 0;
314
        s->first_cpl_leak        = 0;
315
        s->dba_syntax            = 1;
316
        s->skip_syntax           = 1;
317
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
318
        return ac3_parse_header(s);
319
    } else {
320
        s->eac3 = 1;
321
        return ff_eac3_parse_header(s);
322
    }
323
}
324

    
325
/**
326
 * Set stereo downmixing coefficients based on frame header info.
327
 * reference: Section 7.8.2 Downmixing Into Two Channels
328
 */
329
static void set_downmix_coeffs(AC3DecodeContext *s)
330
{
331
    int i;
332
    float cmix = gain_levels[center_levels[s->center_mix_level]];
333
    float smix = gain_levels[surround_levels[s->surround_mix_level]];
334
    float norm0, norm1;
335

    
336
    for(i=0; i<s->fbw_channels; i++) {
337
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
338
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
339
    }
340
    if(s->channel_mode > 1 && s->channel_mode & 1) {
341
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
342
    }
343
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
344
        int nf = s->channel_mode - 2;
345
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
346
    }
347
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
348
        int nf = s->channel_mode - 4;
349
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
350
    }
351

    
352
    /* renormalize */
353
    norm0 = norm1 = 0.0;
354
    for(i=0; i<s->fbw_channels; i++) {
355
        norm0 += s->downmix_coeffs[i][0];
356
        norm1 += s->downmix_coeffs[i][1];
357
    }
358
    norm0 = 1.0f / norm0;
359
    norm1 = 1.0f / norm1;
360
    for(i=0; i<s->fbw_channels; i++) {
361
        s->downmix_coeffs[i][0] *= norm0;
362
        s->downmix_coeffs[i][1] *= norm1;
363
    }
364

    
365
    if(s->output_mode == AC3_CHMODE_MONO) {
366
        for(i=0; i<s->fbw_channels; i++)
367
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
368
    }
369
}
370

    
371
/**
372
 * Decode the grouped exponents according to exponent strategy.
373
 * reference: Section 7.1.3 Exponent Decoding
374
 */
375
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
376
                             uint8_t absexp, int8_t *dexps)
377
{
378
    int i, j, grp, group_size;
379
    int dexp[256];
380
    int expacc, prevexp;
381

    
382
    /* unpack groups */
383
    group_size = exp_strategy + (exp_strategy == EXP_D45);
384
    for(grp=0,i=0; grp<ngrps; grp++) {
385
        expacc = get_bits(gbc, 7);
386
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
387
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
388
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
389
    }
390

    
391
    /* convert to absolute exps and expand groups */
392
    prevexp = absexp;
393
    for(i=0; i<ngrps*3; i++) {
394
        prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
395
        for(j=0; j<group_size; j++) {
396
            dexps[(i*group_size)+j] = prevexp;
397
        }
398
    }
399
}
400

    
401
/**
402
 * Generate transform coefficients for each coupled channel in the coupling
403
 * range using the coupling coefficients and coupling coordinates.
404
 * reference: Section 7.4.3 Coupling Coordinate Format
405
 */
406
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
407
{
408
    int i, j, ch, bnd, subbnd;
409

    
410
    subbnd = -1;
411
    i = s->start_freq[CPL_CH];
412
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
413
        do {
414
            subbnd++;
415
            for(j=0; j<12; j++) {
416
                for(ch=1; ch<=s->fbw_channels; ch++) {
417
                    if(s->channel_in_cpl[ch]) {
418
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
419
                        if (ch == 2 && s->phase_flags[bnd])
420
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
421
                    }
422
                }
423
                i++;
424
            }
425
        } while(s->cpl_band_struct[subbnd]);
426
    }
427
}
428

    
429
/**
430
 * Grouped mantissas for 3-level 5-level and 11-level quantization
431
 */
432
typedef struct {
433
    int b1_mant[3];
434
    int b2_mant[3];
435
    int b4_mant[2];
436
    int b1ptr;
437
    int b2ptr;
438
    int b4ptr;
439
} mant_groups;
440

    
441
/**
442
 * Decode the transform coefficients for a particular channel
443
 * reference: Section 7.3 Quantization and Decoding of Mantissas
444
 */
445
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
446
{
447
    GetBitContext *gbc = &s->gbc;
448
    int i, gcode, tbap, start, end;
449
    uint8_t *exps;
450
    uint8_t *bap;
451
    int *coeffs;
452

    
453
    exps = s->dexps[ch_index];
454
    bap = s->bap[ch_index];
455
    coeffs = s->fixed_coeffs[ch_index];
456
    start = s->start_freq[ch_index];
457
    end = s->end_freq[ch_index];
458

    
459
    for (i = start; i < end; i++) {
460
        tbap = bap[i];
461
        switch (tbap) {
462
            case 0:
463
                coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
464
                break;
465

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

    
477
            case 2:
478
                if(m->b2ptr > 2) {
479
                    gcode = get_bits(gbc, 7);
480
                    m->b2_mant[0] = b2_mantissas[gcode][0];
481
                    m->b2_mant[1] = b2_mantissas[gcode][1];
482
                    m->b2_mant[2] = b2_mantissas[gcode][2];
483
                    m->b2ptr = 0;
484
                }
485
                coeffs[i] = m->b2_mant[m->b2ptr++];
486
                break;
487

    
488
            case 3:
489
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
490
                break;
491

    
492
            case 4:
493
                if(m->b4ptr > 1) {
494
                    gcode = get_bits(gbc, 7);
495
                    m->b4_mant[0] = b4_mantissas[gcode][0];
496
                    m->b4_mant[1] = b4_mantissas[gcode][1];
497
                    m->b4ptr = 0;
498
                }
499
                coeffs[i] = m->b4_mant[m->b4ptr++];
500
                break;
501

    
502
            case 5:
503
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
504
                break;
505

    
506
            default: {
507
                /* asymmetric dequantization */
508
                int qlevel = quantization_tab[tbap];
509
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
510
                break;
511
            }
512
        }
513
        coeffs[i] >>= exps[i];
514
    }
515
}
516

    
517
/**
518
 * Remove random dithering from coefficients with zero-bit mantissas
519
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
520
 */
521
static void remove_dithering(AC3DecodeContext *s) {
522
    int ch, i;
523
    int end=0;
524
    int *coeffs;
525
    uint8_t *bap;
526

    
527
    for(ch=1; ch<=s->fbw_channels; ch++) {
528
        if(!s->dither_flag[ch]) {
529
            coeffs = s->fixed_coeffs[ch];
530
            bap = s->bap[ch];
531
            if(s->channel_in_cpl[ch])
532
                end = s->start_freq[CPL_CH];
533
            else
534
                end = s->end_freq[ch];
535
            for(i=0; i<end; i++) {
536
                if(!bap[i])
537
                    coeffs[i] = 0;
538
            }
539
            if(s->channel_in_cpl[ch]) {
540
                bap = s->bap[CPL_CH];
541
                for(; i<s->end_freq[CPL_CH]; i++) {
542
                    if(!bap[i])
543
                        coeffs[i] = 0;
544
                }
545
            }
546
        }
547
    }
548
}
549

    
550
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
551
                                    mant_groups *m)
552
{
553
    if (!s->channel_uses_aht[ch]) {
554
        ac3_decode_transform_coeffs_ch(s, ch, m);
555
    } else {
556
        /* if AHT is used, mantissas for all blocks are encoded in the first
557
           block of the frame. */
558
        int bin;
559
        if (!blk)
560
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
561
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
562
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
563
        }
564
    }
565
}
566

    
567
/**
568
 * Decode the transform coefficients.
569
 */
570
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
571
{
572
    int ch, end;
573
    int got_cplchan = 0;
574
    mant_groups m;
575

    
576
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
577

    
578
    for (ch = 1; ch <= s->channels; ch++) {
579
        /* transform coefficients for full-bandwidth channel */
580
        decode_transform_coeffs_ch(s, blk, ch, &m);
581
        /* tranform coefficients for coupling channel come right after the
582
           coefficients for the first coupled channel*/
583
        if (s->channel_in_cpl[ch])  {
584
            if (!got_cplchan) {
585
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
586
                calc_transform_coeffs_cpl(s);
587
                got_cplchan = 1;
588
            }
589
            end = s->end_freq[CPL_CH];
590
        } else {
591
            end = s->end_freq[ch];
592
        }
593
        do
594
            s->fixed_coeffs[ch][end] = 0;
595
        while(++end < 256);
596
    }
597

    
598
    /* zero the dithered coefficients for appropriate channels */
599
    remove_dithering(s);
600
}
601

    
602
/**
603
 * Stereo rematrixing.
604
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
605
 */
606
static void do_rematrixing(AC3DecodeContext *s)
607
{
608
    int bnd, i;
609
    int end, bndend;
610
    int tmp0, tmp1;
611

    
612
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
613

    
614
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
615
        if(s->rematrixing_flags[bnd]) {
616
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
617
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
618
                tmp0 = s->fixed_coeffs[1][i];
619
                tmp1 = s->fixed_coeffs[2][i];
620
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
621
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
622
            }
623
        }
624
    }
625
}
626

    
627
/**
628
 * Inverse MDCT Transform.
629
 * Convert frequency domain coefficients to time-domain audio samples.
630
 * reference: Section 7.9.4 Transformation Equations
631
 */
632
static inline void do_imdct(AC3DecodeContext *s, int channels)
633
{
634
    int ch;
635
    float add_bias = s->add_bias;
636
    if(s->out_channels==1 && channels>1)
637
        add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
638

    
639
    for (ch=1; ch<=channels; ch++) {
640
        if (s->block_switch[ch]) {
641
            int i;
642
            float *x = s->tmp_output+128;
643
            for(i=0; i<128; i++)
644
                x[i] = s->transform_coeffs[ch][2*i];
645
            ff_imdct_half(&s->imdct_256, s->tmp_output, x);
646
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
647
            for(i=0; i<128; i++)
648
                x[i] = s->transform_coeffs[ch][2*i+1];
649
            ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
650
        } else {
651
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
652
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
653
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
654
        }
655
    }
656
}
657

    
658
/**
659
 * Downmix the output to mono or stereo.
660
 */
661
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
662
{
663
    int i, j;
664
    float v0, v1;
665
    if(out_ch == 2) {
666
        for(i=0; i<len; i++) {
667
            v0 = v1 = 0.0f;
668
            for(j=0; j<in_ch; j++) {
669
                v0 += samples[j][i] * matrix[j][0];
670
                v1 += samples[j][i] * matrix[j][1];
671
            }
672
            samples[0][i] = v0;
673
            samples[1][i] = v1;
674
        }
675
    } else if(out_ch == 1) {
676
        for(i=0; i<len; i++) {
677
            v0 = 0.0f;
678
            for(j=0; j<in_ch; j++)
679
                v0 += samples[j][i] * matrix[j][0];
680
            samples[0][i] = v0;
681
        }
682
    }
683
}
684

    
685
/**
686
 * Upmix delay samples from stereo to original channel layout.
687
 */
688
static void ac3_upmix_delay(AC3DecodeContext *s)
689
{
690
    int channel_data_size = sizeof(s->delay[0]);
691
    switch(s->channel_mode) {
692
        case AC3_CHMODE_DUALMONO:
693
        case AC3_CHMODE_STEREO:
694
            /* upmix mono to stereo */
695
            memcpy(s->delay[1], s->delay[0], channel_data_size);
696
            break;
697
        case AC3_CHMODE_2F2R:
698
            memset(s->delay[3], 0, channel_data_size);
699
        case AC3_CHMODE_2F1R:
700
            memset(s->delay[2], 0, channel_data_size);
701
            break;
702
        case AC3_CHMODE_3F2R:
703
            memset(s->delay[4], 0, channel_data_size);
704
        case AC3_CHMODE_3F1R:
705
            memset(s->delay[3], 0, channel_data_size);
706
        case AC3_CHMODE_3F:
707
            memcpy(s->delay[2], s->delay[1], channel_data_size);
708
            memset(s->delay[1], 0, channel_data_size);
709
            break;
710
    }
711
}
712

    
713
/**
714
 * Decode a single audio block from the AC-3 bitstream.
715
 */
716
static int decode_audio_block(AC3DecodeContext *s, int blk)
717
{
718
    int fbw_channels = s->fbw_channels;
719
    int channel_mode = s->channel_mode;
720
    int i, bnd, seg, ch;
721
    int different_transforms;
722
    int downmix_output;
723
    int cpl_in_use;
724
    GetBitContext *gbc = &s->gbc;
725
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
726

    
727
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
728

    
729
    /* block switch flags */
730
    different_transforms = 0;
731
    if (s->block_switch_syntax) {
732
        for (ch = 1; ch <= fbw_channels; ch++) {
733
            s->block_switch[ch] = get_bits1(gbc);
734
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
735
                different_transforms = 1;
736
        }
737
    }
738

    
739
    /* dithering flags */
740
    if (s->dither_flag_syntax) {
741
        for (ch = 1; ch <= fbw_channels; ch++) {
742
            s->dither_flag[ch] = get_bits1(gbc);
743
        }
744
    }
745

    
746
    /* dynamic range */
747
    i = !(s->channel_mode);
748
    do {
749
        if(get_bits1(gbc)) {
750
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
751
                                  s->avctx->drc_scale)+1.0;
752
        } else if(blk == 0) {
753
            s->dynamic_range[i] = 1.0f;
754
        }
755
    } while(i--);
756

    
757
    /* spectral extension strategy */
758
    if (s->eac3 && (!blk || get_bits1(gbc))) {
759
        if (get_bits1(gbc)) {
760
            av_log_missing_feature(s->avctx, "Spectral extension", 1);
761
            return -1;
762
        }
763
        /* TODO: parse spectral extension strategy info */
764
    }
765

    
766
    /* TODO: spectral extension coordinates */
767

    
768
    /* coupling strategy */
769
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
770
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
771
        if (!s->eac3)
772
            s->cpl_in_use[blk] = get_bits1(gbc);
773
        if (s->cpl_in_use[blk]) {
774
            /* coupling in use */
775
            int cpl_start_subband, cpl_end_subband;
776

    
777
            if (channel_mode < AC3_CHMODE_STEREO) {
778
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
779
                return -1;
780
            }
781

    
782
            /* check for enhanced coupling */
783
            if (s->eac3 && get_bits1(gbc)) {
784
                /* TODO: parse enhanced coupling strategy info */
785
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
786
                return -1;
787
            }
788

    
789
            /* determine which channels are coupled */
790
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
791
                s->channel_in_cpl[1] = 1;
792
                s->channel_in_cpl[2] = 1;
793
            } else {
794
                for (ch = 1; ch <= fbw_channels; ch++)
795
                    s->channel_in_cpl[ch] = get_bits1(gbc);
796
            }
797

    
798
            /* phase flags in use */
799
            if (channel_mode == AC3_CHMODE_STEREO)
800
                s->phase_flags_in_use = get_bits1(gbc);
801

    
802
            /* coupling frequency range */
803
            /* TODO: modify coupling end freq if spectral extension is used */
804
            cpl_start_subband = get_bits(gbc, 4);
805
            cpl_end_subband   = get_bits(gbc, 4) + 3;
806
            s->num_cpl_subbands = cpl_end_subband - cpl_start_subband;
807
            if (s->num_cpl_subbands < 0) {
808
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d > %d)\n",
809
                       cpl_start_subband, cpl_end_subband);
810
                return -1;
811
            }
812
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
813
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
814

    
815
            /* coupling band structure */
816
            s->num_cpl_bands = s->num_cpl_subbands;
817
            if (!s->eac3 || get_bits1(gbc)) {
818
                for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
819
                    s->cpl_band_struct[bnd] = get_bits1(gbc);
820
                }
821
            } else if (!blk) {
822
                memcpy(s->cpl_band_struct,
823
                       &ff_eac3_default_cpl_band_struct[cpl_start_subband+1],
824
                       s->num_cpl_subbands-1);
825
            }
826
            s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
827

    
828
            /* calculate number of coupling bands based on band structure */
829
            for (bnd = 0; bnd < s->num_cpl_subbands-1; bnd++) {
830
                s->num_cpl_bands -= s->cpl_band_struct[bnd];
831
            }
832
        } else {
833
            /* coupling not in use */
834
            for (ch = 1; ch <= fbw_channels; ch++) {
835
                s->channel_in_cpl[ch] = 0;
836
                s->first_cpl_coords[ch] = 1;
837
            }
838
            s->first_cpl_leak = s->eac3;
839
            s->phase_flags_in_use = 0;
840
        }
841
    } else if (!s->eac3) {
842
        if(!blk) {
843
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
844
            return -1;
845
        } else {
846
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
847
        }
848
    }
849
    cpl_in_use = s->cpl_in_use[blk];
850

    
851
    /* coupling coordinates */
852
    if (cpl_in_use) {
853
        int cpl_coords_exist = 0;
854

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

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

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

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

    
937
    /* decode exponents for each channel */
938
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
939
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
940
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
941
            decode_exponents(gbc, s->exp_strategy[blk][ch],
942
                             s->num_exp_groups[ch], s->dexps[ch][0],
943
                             &s->dexps[ch][s->start_freq[ch]+!!ch]);
944
            if(ch != CPL_CH && ch != s->lfe_ch)
945
                skip_bits(gbc, 2); /* skip gainrng */
946
        }
947
    }
948

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

    
965
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
966
    if(!s->eac3 || !blk){
967
        if(s->snr_offset_strategy && get_bits1(gbc)) {
968
            int snr = 0;
969
            int csnr;
970
            csnr = (get_bits(gbc, 6) - 15) << 4;
971
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
972
                /* snr offset */
973
                if (ch == i || s->snr_offset_strategy == 2)
974
                    snr = (csnr + get_bits(gbc, 4)) << 2;
975
                /* run at least last bit allocation stage if snr offset changes */
976
                if(blk && s->snr_offset[ch] != snr) {
977
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
978
                }
979
                s->snr_offset[ch] = snr;
980

    
981
                /* fast gain (normal AC-3 only) */
982
                if (!s->eac3) {
983
                    int prev = s->fast_gain[ch];
984
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
985
                    /* run last 2 bit allocation stages if fast gain changes */
986
                    if(blk && prev != s->fast_gain[ch])
987
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
988
                }
989
            }
990
        } else if (!s->eac3 && !blk) {
991
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
992
            return -1;
993
        }
994
    }
995

    
996
    /* fast gain (E-AC-3 only) */
997
    if (s->fast_gain_syntax && get_bits1(gbc)) {
998
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
999
            int prev = s->fast_gain[ch];
1000
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1001
            /* run last 2 bit allocation stages if fast gain changes */
1002
            if(blk && prev != s->fast_gain[ch])
1003
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1004
        }
1005
    } else if (s->eac3 && !blk) {
1006
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1007
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1008
    }
1009

    
1010
    /* E-AC-3 to AC-3 converter SNR offset */
1011
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1012
        skip_bits(gbc, 10); // skip converter snr offset
1013
    }
1014

    
1015
    /* coupling leak information */
1016
    if (cpl_in_use) {
1017
        if (s->first_cpl_leak || get_bits1(gbc)) {
1018
            int fl = get_bits(gbc, 3);
1019
            int sl = get_bits(gbc, 3);
1020
            /* run last 2 bit allocation stages for coupling channel if
1021
               coupling leak changes */
1022
            if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1023
                       sl != s->bit_alloc_params.cpl_slow_leak)) {
1024
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1025
            }
1026
            s->bit_alloc_params.cpl_fast_leak = fl;
1027
            s->bit_alloc_params.cpl_slow_leak = sl;
1028
        } else if (!s->eac3 && !blk) {
1029
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1030
            return -1;
1031
        }
1032
        s->first_cpl_leak = 0;
1033
    }
1034

    
1035
    /* delta bit allocation information */
1036
    if (s->dba_syntax && get_bits1(gbc)) {
1037
        /* delta bit allocation exists (strategy) */
1038
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1039
            s->dba_mode[ch] = get_bits(gbc, 2);
1040
            if (s->dba_mode[ch] == DBA_RESERVED) {
1041
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1042
                return -1;
1043
            }
1044
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1045
        }
1046
        /* channel delta offset, len and bit allocation */
1047
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1048
            if (s->dba_mode[ch] == DBA_NEW) {
1049
                s->dba_nsegs[ch] = get_bits(gbc, 3);
1050
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1051
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1052
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1053
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1054
                }
1055
                /* run last 2 bit allocation stages if new dba values */
1056
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1057
            }
1058
        }
1059
    } else if(blk == 0) {
1060
        for(ch=0; ch<=s->channels; ch++) {
1061
            s->dba_mode[ch] = DBA_NONE;
1062
        }
1063
    }
1064

    
1065
    /* Bit allocation */
1066
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1067
        if(bit_alloc_stages[ch] > 2) {
1068
            /* Exponent mapping into PSD and PSD integration */
1069
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1070
                                      s->start_freq[ch], s->end_freq[ch],
1071
                                      s->psd[ch], s->band_psd[ch]);
1072
        }
1073
        if(bit_alloc_stages[ch] > 1) {
1074
            /* Compute excitation function, Compute masking curve, and
1075
               Apply delta bit allocation */
1076
            ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1077
                                       s->start_freq[ch], s->end_freq[ch],
1078
                                       s->fast_gain[ch], (ch == s->lfe_ch),
1079
                                       s->dba_mode[ch], s->dba_nsegs[ch],
1080
                                       s->dba_offsets[ch], s->dba_lengths[ch],
1081
                                       s->dba_values[ch], s->mask[ch]);
1082
        }
1083
        if(bit_alloc_stages[ch] > 0) {
1084
            /* Compute bit allocation */
1085
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1086
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1087
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1088
                                      s->start_freq[ch], s->end_freq[ch],
1089
                                      s->snr_offset[ch],
1090
                                      s->bit_alloc_params.floor,
1091
                                      bap_tab, s->bap[ch]);
1092
        }
1093
    }
1094

    
1095
    /* unused dummy data */
1096
    if (s->skip_syntax && get_bits1(gbc)) {
1097
        int skipl = get_bits(gbc, 9);
1098
        while(skipl--)
1099
            skip_bits(gbc, 8);
1100
    }
1101

    
1102
    /* unpack the transform coefficients
1103
       this also uncouples channels if coupling is in use. */
1104
    decode_transform_coeffs(s, blk);
1105

    
1106
    /* TODO: generate enhanced coupling coordinates and uncouple */
1107

    
1108
    /* TODO: apply spectral extension */
1109

    
1110
    /* recover coefficients if rematrixing is in use */
1111
    if(s->channel_mode == AC3_CHMODE_STEREO)
1112
        do_rematrixing(s);
1113

    
1114
    /* apply scaling to coefficients (headroom, dynrng) */
1115
    for(ch=1; ch<=s->channels; ch++) {
1116
        float gain = s->mul_bias / 4194304.0f;
1117
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1118
            gain *= s->dynamic_range[ch-1];
1119
        } else {
1120
            gain *= s->dynamic_range[0];
1121
        }
1122
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1123
    }
1124

    
1125
    /* downmix and MDCT. order depends on whether block switching is used for
1126
       any channel in this block. this is because coefficients for the long
1127
       and short transforms cannot be mixed. */
1128
    downmix_output = s->channels != s->out_channels &&
1129
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1130
                     s->fbw_channels == s->out_channels);
1131
    if(different_transforms) {
1132
        /* the delay samples have already been downmixed, so we upmix the delay
1133
           samples in order to reconstruct all channels before downmixing. */
1134
        if(s->downmixed) {
1135
            s->downmixed = 0;
1136
            ac3_upmix_delay(s);
1137
        }
1138

    
1139
        do_imdct(s, s->channels);
1140

    
1141
        if(downmix_output) {
1142
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1143
        }
1144
    } else {
1145
        if(downmix_output) {
1146
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1147
        }
1148

    
1149
        if(downmix_output && !s->downmixed) {
1150
            s->downmixed = 1;
1151
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1152
        }
1153

    
1154
        do_imdct(s, s->out_channels);
1155
    }
1156

    
1157
    return 0;
1158
}
1159

    
1160
/**
1161
 * Decode a single AC-3 frame.
1162
 */
1163
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1164
                            const uint8_t *buf, int buf_size)
1165
{
1166
    AC3DecodeContext *s = avctx->priv_data;
1167
    int16_t *out_samples = (int16_t *)data;
1168
    int blk, ch, err;
1169

    
1170
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1171
    if (s->input_buffer) {
1172
        /* copy input buffer to decoder context to avoid reading past the end
1173
           of the buffer, which can be caused by a damaged input stream. */
1174
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1175
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1176
    } else {
1177
        init_get_bits(&s->gbc, buf, buf_size * 8);
1178
    }
1179

    
1180
    /* parse the syncinfo */
1181
    *data_size = 0;
1182
    err = parse_frame_header(s);
1183

    
1184
    /* check that reported frame size fits in input buffer */
1185
    if(s->frame_size > buf_size) {
1186
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1187
        err = AC3_PARSE_ERROR_FRAME_SIZE;
1188
    }
1189

    
1190
    /* check for crc mismatch */
1191
    if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
1192
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1193
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1194
            err = AC3_PARSE_ERROR_CRC;
1195
        }
1196
    }
1197

    
1198
    if(err && err != AC3_PARSE_ERROR_CRC) {
1199
        switch(err) {
1200
            case AC3_PARSE_ERROR_SYNC:
1201
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1202
                return -1;
1203
            case AC3_PARSE_ERROR_BSID:
1204
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1205
                break;
1206
            case AC3_PARSE_ERROR_SAMPLE_RATE:
1207
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1208
                break;
1209
            case AC3_PARSE_ERROR_FRAME_SIZE:
1210
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1211
                break;
1212
            case AC3_PARSE_ERROR_FRAME_TYPE:
1213
                /* skip frame if CRC is ok. otherwise use error concealment. */
1214
                /* TODO: add support for substreams and dependent frames */
1215
                if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1216
                    av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1217
                    return s->frame_size;
1218
                } else {
1219
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1220
                }
1221
                break;
1222
            default:
1223
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1224
                break;
1225
        }
1226
    }
1227

    
1228
    /* if frame is ok, set audio parameters */
1229
    if (!err) {
1230
        avctx->sample_rate = s->sample_rate;
1231
        avctx->bit_rate = s->bit_rate;
1232

    
1233
        /* channel config */
1234
        s->out_channels = s->channels;
1235
        s->output_mode = s->channel_mode;
1236
        if(s->lfe_on)
1237
            s->output_mode |= AC3_OUTPUT_LFEON;
1238
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1239
                avctx->request_channels < s->channels) {
1240
            s->out_channels = avctx->request_channels;
1241
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1242
        }
1243
        avctx->channels = s->out_channels;
1244

    
1245
        /* set downmixing coefficients if needed */
1246
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1247
                s->fbw_channels == s->out_channels)) {
1248
            set_downmix_coeffs(s);
1249
        }
1250
    } else if (!s->out_channels) {
1251
        s->out_channels = avctx->channels;
1252
        if(s->out_channels < s->channels)
1253
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1254
    }
1255

    
1256
    /* decode the audio blocks */
1257
    for (blk = 0; blk < s->num_blocks; blk++) {
1258
        const float *output[s->out_channels];
1259
        if (!err && decode_audio_block(s, blk)) {
1260
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1261
        }
1262
        for (ch = 0; ch < s->out_channels; ch++)
1263
            output[ch] = s->output[ch];
1264
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1265
        out_samples += 256 * s->out_channels;
1266
    }
1267
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1268
    return s->frame_size;
1269
}
1270

    
1271
/**
1272
 * Uninitialize the AC-3 decoder.
1273
 */
1274
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1275
{
1276
    AC3DecodeContext *s = avctx->priv_data;
1277
    ff_mdct_end(&s->imdct_512);
1278
    ff_mdct_end(&s->imdct_256);
1279

    
1280
    av_freep(&s->input_buffer);
1281

    
1282
    return 0;
1283
}
1284

    
1285
AVCodec ac3_decoder = {
1286
    .name = "ac3",
1287
    .type = CODEC_TYPE_AUDIO,
1288
    .id = CODEC_ID_AC3,
1289
    .priv_data_size = sizeof (AC3DecodeContext),
1290
    .init = ac3_decode_init,
1291
    .close = ac3_decode_end,
1292
    .decode = ac3_decode_frame,
1293
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1294
};
1295

    
1296
AVCodec eac3_decoder = {
1297
    .name = "eac3",
1298
    .type = CODEC_TYPE_AUDIO,
1299
    .id = CODEC_ID_EAC3,
1300
    .priv_data_size = sizeof (AC3DecodeContext),
1301
    .init = ac3_decode_init,
1302
    .close = ac3_decode_end,
1303
    .decode = ac3_decode_frame,
1304
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1305
};