Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 1754fe4d

History | View | Annotate | Download (47.6 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
 * This file is part of FFmpeg.
11
 *
12
 * FFmpeg is free software; you can redistribute it and/or
13
 * modify it under the terms of the GNU Lesser General Public
14
 * License as published by the Free Software Foundation; either
15
 * version 2.1 of the License, or (at your option) any later version.
16
 *
17
 * FFmpeg is distributed in the hope that it will be useful,
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 * Lesser General Public License for more details.
21
 *
22
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with FFmpeg; if not, write to the Free Software
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25
 */
26

    
27
#include <stdio.h>
28
#include <stddef.h>
29
#include <math.h>
30
#include <string.h>
31

    
32
#include "libavutil/crc.h"
33
#include "internal.h"
34
#include "aac_ac3_parser.h"
35
#include "ac3_parser.h"
36
#include "ac3dec.h"
37
#include "ac3dec_data.h"
38

    
39
/** Large enough for maximum possible frame size when the specification limit is ignored */
40
#define AC3_FRAME_BUFFER_SIZE 32768
41

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

    
48

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

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

    
65
/** dynamic range table. converts codes to scale factors. */
66
static float dynamic_range_tab[256];
67

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

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

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

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

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

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

    
129
/*
130
 * Initialize tables at runtime.
131
 */
132
static av_cold void ac3_tables_init(void)
133
{
134
    int i;
135

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

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

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

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

    
181

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

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

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

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

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

    
222
    avctx->sample_fmt = SAMPLE_FMT_S16;
223
    return 0;
224
}
225

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

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

    
248
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
249

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

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

    
265
    return 0;
266
}
267

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

    
276
    err = ff_ac3_parse_header(&s->gbc, &hdr);
277
    if(err)
278
        return err;
279

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

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

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

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

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

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

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

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

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

    
389
    /* convert to absolute exps and expand groups */
390
    prevexp = absexp;
391
    for(i=0,j=0; i<ngrps*3; i++) {
392
        prevexp += dexp[i] - 2;
393
        if (prevexp > 24U)
394
            return -1;
395
        switch (group_size) {
396
            case 4: dexps[j++] = prevexp;
397
                    dexps[j++] = prevexp;
398
            case 2: dexps[j++] = prevexp;
399
            case 1: dexps[j++] = prevexp;
400
        }
401
    }
402
    return 0;
403
}
404

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

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

    
433
/**
434
 * Grouped mantissas for 3-level 5-level and 11-level quantization
435
 */
436
typedef struct {
437
    int b1_mant[2];
438
    int b2_mant[2];
439
    int b4_mant;
440
    int b1;
441
    int b2;
442
    int b4;
443
} mant_groups;
444

    
445
/**
446
 * Decode the transform coefficients for a particular channel
447
 * reference: Section 7.3 Quantization and Decoding of Mantissas
448
 */
449
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
450
{
451
    int start_freq = s->start_freq[ch_index];
452
    int end_freq = s->end_freq[ch_index];
453
    uint8_t *baps = s->bap[ch_index];
454
    int8_t *exps = s->dexps[ch_index];
455
    int *coeffs = s->fixed_coeffs[ch_index];
456
    GetBitContext *gbc = &s->gbc;
457
    int freq;
458

    
459
    for(freq = start_freq; freq < end_freq; freq++){
460
        int bap = baps[freq];
461
        int mantissa;
462
        switch(bap){
463
            case 0:
464
                mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
465
                break;
466
            case 1:
467
                if(m->b1){
468
                    m->b1--;
469
                    mantissa = m->b1_mant[m->b1];
470
                }
471
                else{
472
                    int bits      = get_bits(gbc, 5);
473
                    mantissa      = b1_mantissas[bits][0];
474
                    m->b1_mant[1] = b1_mantissas[bits][1];
475
                    m->b1_mant[0] = b1_mantissas[bits][2];
476
                    m->b1         = 2;
477
                }
478
                break;
479
            case 2:
480
                if(m->b2){
481
                    m->b2--;
482
                    mantissa = m->b2_mant[m->b2];
483
                }
484
                else{
485
                    int bits      = get_bits(gbc, 7);
486
                    mantissa      = b2_mantissas[bits][0];
487
                    m->b2_mant[1] = b2_mantissas[bits][1];
488
                    m->b2_mant[0] = b2_mantissas[bits][2];
489
                    m->b2         = 2;
490
                }
491
                break;
492
            case 3:
493
                mantissa = b3_mantissas[get_bits(gbc, 3)];
494
                break;
495
            case 4:
496
                if(m->b4){
497
                    m->b4 = 0;
498
                    mantissa = m->b4_mant;
499
                }
500
                else{
501
                    int bits   = get_bits(gbc, 7);
502
                    mantissa   = b4_mantissas[bits][0];
503
                    m->b4_mant = b4_mantissas[bits][1];
504
                    m->b4      = 1;
505
                }
506
                break;
507
            case 5:
508
                mantissa = b5_mantissas[get_bits(gbc, 4)];
509
                break;
510
            default: /* 6 to 15 */
511
                mantissa = get_bits(gbc, quantization_tab[bap]);
512
                /* Shift mantissa and sign-extend it. */
513
                mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
514
                break;
515
        }
516
        coeffs[freq] = mantissa >> exps[freq];
517
    }
518
}
519

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

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

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

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

    
579
    m.b1 = m.b2 = m.b4 = 0;
580

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

    
601
    /* zero the dithered coefficients for appropriate channels */
602
    remove_dithering(s);
603
}
604

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

    
615
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
616

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

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

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

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

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

    
716
/**
717
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
718
 * @param[in] gbc bit reader context
719
 * @param[in] blk block number
720
 * @param[in] eac3 flag to indicate E-AC-3
721
 * @param[in] ecpl flag to indicate enhanced coupling
722
 * @param[in] start_subband subband number for start of range
723
 * @param[in] end_subband subband number for end of range
724
 * @param[in] default_band_struct default band structure table
725
 * @param[out] band_struct decoded band structure
726
 * @param[out] num_bands number of bands (optionally NULL)
727
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
728
 */
729
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
730
                                  int ecpl, int start_subband, int end_subband,
731
                                  const uint8_t *default_band_struct,
732
                                  uint8_t *band_struct, int *num_bands,
733
                                  uint8_t *band_sizes)
734
{
735
    int subbnd, bnd, n_subbands, n_bands=0;
736
    uint8_t bnd_sz[22];
737

    
738
    n_subbands = end_subband - start_subband;
739

    
740
    /* decode band structure from bitstream or use default */
741
    if (!eac3 || get_bits1(gbc)) {
742
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
743
            band_struct[subbnd] = get_bits1(gbc);
744
        }
745
    } else if (!blk) {
746
        memcpy(band_struct,
747
               &default_band_struct[start_subband+1],
748
               n_subbands-1);
749
    }
750
    band_struct[n_subbands-1] = 0;
751

    
752
    /* calculate number of bands and band sizes based on band structure.
753
       note that the first 4 subbands in enhanced coupling span only 6 bins
754
       instead of 12. */
755
    if (num_bands || band_sizes ) {
756
        n_bands = n_subbands;
757
        bnd_sz[0] = ecpl ? 6 : 12;
758
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
759
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
760
            if (band_struct[subbnd-1]) {
761
                n_bands--;
762
                bnd_sz[bnd] += subbnd_size;
763
            } else {
764
                bnd_sz[++bnd] = subbnd_size;
765
            }
766
        }
767
    }
768

    
769
    /* set optional output params */
770
    if (num_bands)
771
        *num_bands = n_bands;
772
    if (band_sizes)
773
        memcpy(band_sizes, bnd_sz, n_bands);
774
}
775

    
776
/**
777
 * Decode a single audio block from the AC-3 bitstream.
778
 */
779
static int decode_audio_block(AC3DecodeContext *s, int blk)
780
{
781
    int fbw_channels = s->fbw_channels;
782
    int channel_mode = s->channel_mode;
783
    int i, bnd, seg, ch;
784
    int different_transforms;
785
    int downmix_output;
786
    int cpl_in_use;
787
    GetBitContext *gbc = &s->gbc;
788
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
789

    
790
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
791

    
792
    /* block switch flags */
793
    different_transforms = 0;
794
    if (s->block_switch_syntax) {
795
        for (ch = 1; ch <= fbw_channels; ch++) {
796
            s->block_switch[ch] = get_bits1(gbc);
797
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
798
                different_transforms = 1;
799
        }
800
    }
801

    
802
    /* dithering flags */
803
    if (s->dither_flag_syntax) {
804
        for (ch = 1; ch <= fbw_channels; ch++) {
805
            s->dither_flag[ch] = get_bits1(gbc);
806
        }
807
    }
808

    
809
    /* dynamic range */
810
    i = !(s->channel_mode);
811
    do {
812
        if(get_bits1(gbc)) {
813
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
814
                                  s->avctx->drc_scale)+1.0;
815
        } else if(blk == 0) {
816
            s->dynamic_range[i] = 1.0f;
817
        }
818
    } while(i--);
819

    
820
    /* spectral extension strategy */
821
    if (s->eac3 && (!blk || get_bits1(gbc))) {
822
        if (get_bits1(gbc)) {
823
            ff_log_missing_feature(s->avctx, "Spectral extension", 1);
824
            return -1;
825
        }
826
        /* TODO: parse spectral extension strategy info */
827
    }
828

    
829
    /* TODO: spectral extension coordinates */
830

    
831
    /* coupling strategy */
832
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
833
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
834
        if (!s->eac3)
835
            s->cpl_in_use[blk] = get_bits1(gbc);
836
        if (s->cpl_in_use[blk]) {
837
            /* coupling in use */
838
            int cpl_start_subband, cpl_end_subband;
839

    
840
            if (channel_mode < AC3_CHMODE_STEREO) {
841
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
842
                return -1;
843
            }
844

    
845
            /* check for enhanced coupling */
846
            if (s->eac3 && get_bits1(gbc)) {
847
                /* TODO: parse enhanced coupling strategy info */
848
                ff_log_missing_feature(s->avctx, "Enhanced coupling", 1);
849
                return -1;
850
            }
851

    
852
            /* determine which channels are coupled */
853
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
854
                s->channel_in_cpl[1] = 1;
855
                s->channel_in_cpl[2] = 1;
856
            } else {
857
                for (ch = 1; ch <= fbw_channels; ch++)
858
                    s->channel_in_cpl[ch] = get_bits1(gbc);
859
            }
860

    
861
            /* phase flags in use */
862
            if (channel_mode == AC3_CHMODE_STEREO)
863
                s->phase_flags_in_use = get_bits1(gbc);
864

    
865
            /* coupling frequency range */
866
            /* TODO: modify coupling end freq if spectral extension is used */
867
            cpl_start_subband = get_bits(gbc, 4);
868
            cpl_end_subband   = get_bits(gbc, 4) + 3;
869
            if (cpl_start_subband >= cpl_end_subband) {
870
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
871
                       cpl_start_subband, cpl_end_subband);
872
                return -1;
873
            }
874
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
875
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
876

    
877
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
878
                                  cpl_end_subband,
879
                                  ff_eac3_default_cpl_band_struct,
880
                                  s->cpl_band_struct, &s->num_cpl_bands, NULL);
881
        } else {
882
            /* coupling not in use */
883
            for (ch = 1; ch <= fbw_channels; ch++) {
884
                s->channel_in_cpl[ch] = 0;
885
                s->first_cpl_coords[ch] = 1;
886
            }
887
            s->first_cpl_leak = s->eac3;
888
            s->phase_flags_in_use = 0;
889
        }
890
    } else if (!s->eac3) {
891
        if(!blk) {
892
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
893
            return -1;
894
        } else {
895
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
896
        }
897
    }
898
    cpl_in_use = s->cpl_in_use[blk];
899

    
900
    /* coupling coordinates */
901
    if (cpl_in_use) {
902
        int cpl_coords_exist = 0;
903

    
904
        for (ch = 1; ch <= fbw_channels; ch++) {
905
            if (s->channel_in_cpl[ch]) {
906
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
907
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
908
                    s->first_cpl_coords[ch] = 0;
909
                    cpl_coords_exist = 1;
910
                    master_cpl_coord = 3 * get_bits(gbc, 2);
911
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
912
                        cpl_coord_exp = get_bits(gbc, 4);
913
                        cpl_coord_mant = get_bits(gbc, 4);
914
                        if (cpl_coord_exp == 15)
915
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
916
                        else
917
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
918
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
919
                    }
920
                } else if (!blk) {
921
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
922
                    return -1;
923
                }
924
            } else {
925
                /* channel not in coupling */
926
                s->first_cpl_coords[ch] = 1;
927
            }
928
        }
929
        /* phase flags */
930
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
931
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
932
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
933
            }
934
        }
935
    }
936

    
937
    /* stereo rematrixing strategy and band structure */
938
    if (channel_mode == AC3_CHMODE_STEREO) {
939
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
940
            s->num_rematrixing_bands = 4;
941
            if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
942
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
943
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
944
                s->rematrixing_flags[bnd] = get_bits1(gbc);
945
        } else if (!blk) {
946
            av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
947
            return -1;
948
        }
949
    }
950

    
951
    /* exponent strategies for each channel */
952
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
953
        if (!s->eac3)
954
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
955
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
956
            bit_alloc_stages[ch] = 3;
957
    }
958

    
959
    /* channel bandwidth */
960
    for (ch = 1; ch <= fbw_channels; ch++) {
961
        s->start_freq[ch] = 0;
962
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
963
            int group_size;
964
            int prev = s->end_freq[ch];
965
            if (s->channel_in_cpl[ch])
966
                s->end_freq[ch] = s->start_freq[CPL_CH];
967
            else {
968
                int bandwidth_code = get_bits(gbc, 6);
969
                if (bandwidth_code > 60) {
970
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
971
                    return -1;
972
                }
973
                s->end_freq[ch] = bandwidth_code * 3 + 73;
974
            }
975
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
976
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
977
            if(blk > 0 && s->end_freq[ch] != prev)
978
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
979
        }
980
    }
981
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
982
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
983
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
984
    }
985

    
986
    /* decode exponents for each channel */
987
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
988
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
989
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
990
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
991
                                 s->num_exp_groups[ch], s->dexps[ch][0],
992
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
993
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
994
                return -1;
995
            }
996
            if(ch != CPL_CH && ch != s->lfe_ch)
997
                skip_bits(gbc, 2); /* skip gainrng */
998
        }
999
    }
1000

    
1001
    /* bit allocation information */
1002
    if (s->bit_allocation_syntax) {
1003
        if (get_bits1(gbc)) {
1004
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1005
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1006
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1007
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1008
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1009
            for(ch=!cpl_in_use; ch<=s->channels; ch++)
1010
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1011
        } else if (!blk) {
1012
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1013
            return -1;
1014
        }
1015
    }
1016

    
1017
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1018
    if(!s->eac3 || !blk){
1019
        if(s->snr_offset_strategy && get_bits1(gbc)) {
1020
            int snr = 0;
1021
            int csnr;
1022
            csnr = (get_bits(gbc, 6) - 15) << 4;
1023
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1024
                /* snr offset */
1025
                if (ch == i || s->snr_offset_strategy == 2)
1026
                    snr = (csnr + get_bits(gbc, 4)) << 2;
1027
                /* run at least last bit allocation stage if snr offset changes */
1028
                if(blk && s->snr_offset[ch] != snr) {
1029
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1030
                }
1031
                s->snr_offset[ch] = snr;
1032

    
1033
                /* fast gain (normal AC-3 only) */
1034
                if (!s->eac3) {
1035
                    int prev = s->fast_gain[ch];
1036
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1037
                    /* run last 2 bit allocation stages if fast gain changes */
1038
                    if(blk && prev != s->fast_gain[ch])
1039
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1040
                }
1041
            }
1042
        } else if (!s->eac3 && !blk) {
1043
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1044
            return -1;
1045
        }
1046
    }
1047

    
1048
    /* fast gain (E-AC-3 only) */
1049
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1050
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1051
            int prev = s->fast_gain[ch];
1052
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1053
            /* run last 2 bit allocation stages if fast gain changes */
1054
            if(blk && prev != s->fast_gain[ch])
1055
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1056
        }
1057
    } else if (s->eac3 && !blk) {
1058
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1059
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1060
    }
1061

    
1062
    /* E-AC-3 to AC-3 converter SNR offset */
1063
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1064
        skip_bits(gbc, 10); // skip converter snr offset
1065
    }
1066

    
1067
    /* coupling leak information */
1068
    if (cpl_in_use) {
1069
        if (s->first_cpl_leak || get_bits1(gbc)) {
1070
            int fl = get_bits(gbc, 3);
1071
            int sl = get_bits(gbc, 3);
1072
            /* run last 2 bit allocation stages for coupling channel if
1073
               coupling leak changes */
1074
            if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1075
                       sl != s->bit_alloc_params.cpl_slow_leak)) {
1076
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1077
            }
1078
            s->bit_alloc_params.cpl_fast_leak = fl;
1079
            s->bit_alloc_params.cpl_slow_leak = sl;
1080
        } else if (!s->eac3 && !blk) {
1081
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1082
            return -1;
1083
        }
1084
        s->first_cpl_leak = 0;
1085
    }
1086

    
1087
    /* delta bit allocation information */
1088
    if (s->dba_syntax && get_bits1(gbc)) {
1089
        /* delta bit allocation exists (strategy) */
1090
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1091
            s->dba_mode[ch] = get_bits(gbc, 2);
1092
            if (s->dba_mode[ch] == DBA_RESERVED) {
1093
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1094
                return -1;
1095
            }
1096
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1097
        }
1098
        /* channel delta offset, len and bit allocation */
1099
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1100
            if (s->dba_mode[ch] == DBA_NEW) {
1101
                s->dba_nsegs[ch] = get_bits(gbc, 3);
1102
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1103
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1104
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1105
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1106
                }
1107
                /* run last 2 bit allocation stages if new dba values */
1108
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1109
            }
1110
        }
1111
    } else if(blk == 0) {
1112
        for(ch=0; ch<=s->channels; ch++) {
1113
            s->dba_mode[ch] = DBA_NONE;
1114
        }
1115
    }
1116

    
1117
    /* Bit allocation */
1118
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1119
        if(bit_alloc_stages[ch] > 2) {
1120
            /* Exponent mapping into PSD and PSD integration */
1121
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1122
                                      s->start_freq[ch], s->end_freq[ch],
1123
                                      s->psd[ch], s->band_psd[ch]);
1124
        }
1125
        if(bit_alloc_stages[ch] > 1) {
1126
            /* Compute excitation function, Compute masking curve, and
1127
               Apply delta bit allocation */
1128
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1129
                                           s->start_freq[ch], s->end_freq[ch],
1130
                                           s->fast_gain[ch], (ch == s->lfe_ch),
1131
                                           s->dba_mode[ch], s->dba_nsegs[ch],
1132
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1133
                                           s->dba_values[ch], s->mask[ch])) {
1134
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1135
                return -1;
1136
            }
1137
        }
1138
        if(bit_alloc_stages[ch] > 0) {
1139
            /* Compute bit allocation */
1140
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1141
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1142
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1143
                                      s->start_freq[ch], s->end_freq[ch],
1144
                                      s->snr_offset[ch],
1145
                                      s->bit_alloc_params.floor,
1146
                                      bap_tab, s->bap[ch]);
1147
        }
1148
    }
1149

    
1150
    /* unused dummy data */
1151
    if (s->skip_syntax && get_bits1(gbc)) {
1152
        int skipl = get_bits(gbc, 9);
1153
        while(skipl--)
1154
            skip_bits(gbc, 8);
1155
    }
1156

    
1157
    /* unpack the transform coefficients
1158
       this also uncouples channels if coupling is in use. */
1159
    decode_transform_coeffs(s, blk);
1160

    
1161
    /* TODO: generate enhanced coupling coordinates and uncouple */
1162

    
1163
    /* TODO: apply spectral extension */
1164

    
1165
    /* recover coefficients if rematrixing is in use */
1166
    if(s->channel_mode == AC3_CHMODE_STEREO)
1167
        do_rematrixing(s);
1168

    
1169
    /* apply scaling to coefficients (headroom, dynrng) */
1170
    for(ch=1; ch<=s->channels; ch++) {
1171
        float gain = s->mul_bias / 4194304.0f;
1172
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1173
            gain *= s->dynamic_range[ch-1];
1174
        } else {
1175
            gain *= s->dynamic_range[0];
1176
        }
1177
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1178
    }
1179

    
1180
    /* downmix and MDCT. order depends on whether block switching is used for
1181
       any channel in this block. this is because coefficients for the long
1182
       and short transforms cannot be mixed. */
1183
    downmix_output = s->channels != s->out_channels &&
1184
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1185
                     s->fbw_channels == s->out_channels);
1186
    if(different_transforms) {
1187
        /* the delay samples have already been downmixed, so we upmix the delay
1188
           samples in order to reconstruct all channels before downmixing. */
1189
        if(s->downmixed) {
1190
            s->downmixed = 0;
1191
            ac3_upmix_delay(s);
1192
        }
1193

    
1194
        do_imdct(s, s->channels);
1195

    
1196
        if(downmix_output) {
1197
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1198
        }
1199
    } else {
1200
        if(downmix_output) {
1201
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1202
        }
1203

    
1204
        if(downmix_output && !s->downmixed) {
1205
            s->downmixed = 1;
1206
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1207
        }
1208

    
1209
        do_imdct(s, s->out_channels);
1210
    }
1211

    
1212
    return 0;
1213
}
1214

    
1215
/**
1216
 * Decode a single AC-3 frame.
1217
 */
1218
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1219
                            AVPacket *avpkt)
1220
{
1221
    const uint8_t *buf = avpkt->data;
1222
    int buf_size = avpkt->size;
1223
    AC3DecodeContext *s = avctx->priv_data;
1224
    int16_t *out_samples = (int16_t *)data;
1225
    int blk, ch, err;
1226
    const uint8_t *channel_map;
1227
    const float *output[AC3_MAX_CHANNELS];
1228

    
1229
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1230
    if (s->input_buffer) {
1231
        /* copy input buffer to decoder context to avoid reading past the end
1232
           of the buffer, which can be caused by a damaged input stream. */
1233
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1234
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1235
    } else {
1236
        init_get_bits(&s->gbc, buf, buf_size * 8);
1237
    }
1238

    
1239
    /* parse the syncinfo */
1240
    *data_size = 0;
1241
    err = parse_frame_header(s);
1242

    
1243
    /* check that reported frame size fits in input buffer */
1244
    if(s->frame_size > buf_size) {
1245
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1246
        err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1247
    }
1248

    
1249
    /* check for crc mismatch */
1250
    if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
1251
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1252
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1253
            err = AAC_AC3_PARSE_ERROR_CRC;
1254
        }
1255
    }
1256

    
1257
    if(err && err != AAC_AC3_PARSE_ERROR_CRC) {
1258
        switch(err) {
1259
            case AAC_AC3_PARSE_ERROR_SYNC:
1260
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1261
                return -1;
1262
            case AAC_AC3_PARSE_ERROR_BSID:
1263
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1264
                break;
1265
            case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1266
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1267
                break;
1268
            case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1269
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1270
                break;
1271
            case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1272
                /* skip frame if CRC is ok. otherwise use error concealment. */
1273
                /* TODO: add support for substreams and dependent frames */
1274
                if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1275
                    av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1276
                    return s->frame_size;
1277
                } else {
1278
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1279
                }
1280
                break;
1281
            default:
1282
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1283
                break;
1284
        }
1285
    }
1286

    
1287
    /* if frame is ok, set audio parameters */
1288
    if (!err) {
1289
        avctx->sample_rate = s->sample_rate;
1290
        avctx->bit_rate = s->bit_rate;
1291

    
1292
        /* channel config */
1293
        s->out_channels = s->channels;
1294
        s->output_mode = s->channel_mode;
1295
        if(s->lfe_on)
1296
            s->output_mode |= AC3_OUTPUT_LFEON;
1297
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1298
                avctx->request_channels < s->channels) {
1299
            s->out_channels = avctx->request_channels;
1300
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1301
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1302
        }
1303
        avctx->channels = s->out_channels;
1304
        avctx->channel_layout = s->channel_layout;
1305

    
1306
        /* set downmixing coefficients if needed */
1307
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1308
                s->fbw_channels == s->out_channels)) {
1309
            set_downmix_coeffs(s);
1310
        }
1311
    } else if (!s->out_channels) {
1312
        s->out_channels = avctx->channels;
1313
        if(s->out_channels < s->channels)
1314
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1315
    }
1316

    
1317
    /* decode the audio blocks */
1318
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1319
    for (ch = 0; ch < s->out_channels; ch++)
1320
        output[ch] = s->output[channel_map[ch]];
1321
    for (blk = 0; blk < s->num_blocks; blk++) {
1322
        if (!err && decode_audio_block(s, blk)) {
1323
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1324
            err = 1;
1325
        }
1326
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1327
        out_samples += 256 * s->out_channels;
1328
    }
1329
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1330
    return s->frame_size;
1331
}
1332

    
1333
/**
1334
 * Uninitialize the AC-3 decoder.
1335
 */
1336
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1337
{
1338
    AC3DecodeContext *s = avctx->priv_data;
1339
    ff_mdct_end(&s->imdct_512);
1340
    ff_mdct_end(&s->imdct_256);
1341

    
1342
    av_freep(&s->input_buffer);
1343

    
1344
    return 0;
1345
}
1346

    
1347
AVCodec ac3_decoder = {
1348
    .name = "ac3",
1349
    .type = CODEC_TYPE_AUDIO,
1350
    .id = CODEC_ID_AC3,
1351
    .priv_data_size = sizeof (AC3DecodeContext),
1352
    .init = ac3_decode_init,
1353
    .close = ac3_decode_end,
1354
    .decode = ac3_decode_frame,
1355
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1356
};
1357

    
1358
AVCodec eac3_decoder = {
1359
    .name = "eac3",
1360
    .type = CODEC_TYPE_AUDIO,
1361
    .id = CODEC_ID_EAC3,
1362
    .priv_data_size = sizeof (AC3DecodeContext),
1363
    .init = ac3_decode_init,
1364
    .close = ac3_decode_end,
1365
    .decode = ac3_decode_frame,
1366
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1367
};