Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 7d485f16

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
 * 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 "internal.h"
39
#include "aac_ac3_parser.h"
40
#include "ac3_parser.h"
41
#include "ac3dec.h"
42
#include "ac3dec_data.h"
43

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

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

    
53

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
186

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

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

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

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

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

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

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

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

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

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

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

    
270
    return 0;
271
}
272

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
438
/**
439
 * Grouped mantissas for 3-level 5-level and 11-level quantization
440
 */
441
typedef struct {
442
    int b1_mant[3];
443
    int b2_mant[3];
444
    int b4_mant[2];
445
    int b1ptr;
446
    int b2ptr;
447
    int b4ptr;
448
} mant_groups;
449

    
450
/**
451
 * Decode the transform coefficients for a particular channel
452
 * reference: Section 7.3 Quantization and Decoding of Mantissas
453
 */
454
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
455
{
456
    GetBitContext *gbc = &s->gbc;
457
    int i, gcode, tbap, start, end;
458
    uint8_t *exps;
459
    uint8_t *bap;
460
    int *coeffs;
461

    
462
    exps = s->dexps[ch_index];
463
    bap = s->bap[ch_index];
464
    coeffs = s->fixed_coeffs[ch_index];
465
    start = s->start_freq[ch_index];
466
    end = s->end_freq[ch_index];
467

    
468
    for (i = start; i < end; i++) {
469
        tbap = bap[i];
470
        switch (tbap) {
471
            case 0:
472
                coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
473
                break;
474

    
475
            case 1:
476
                if(m->b1ptr > 2) {
477
                    gcode = get_bits(gbc, 5);
478
                    m->b1_mant[0] = b1_mantissas[gcode][0];
479
                    m->b1_mant[1] = b1_mantissas[gcode][1];
480
                    m->b1_mant[2] = b1_mantissas[gcode][2];
481
                    m->b1ptr = 0;
482
                }
483
                coeffs[i] = m->b1_mant[m->b1ptr++];
484
                break;
485

    
486
            case 2:
487
                if(m->b2ptr > 2) {
488
                    gcode = get_bits(gbc, 7);
489
                    m->b2_mant[0] = b2_mantissas[gcode][0];
490
                    m->b2_mant[1] = b2_mantissas[gcode][1];
491
                    m->b2_mant[2] = b2_mantissas[gcode][2];
492
                    m->b2ptr = 0;
493
                }
494
                coeffs[i] = m->b2_mant[m->b2ptr++];
495
                break;
496

    
497
            case 3:
498
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
499
                break;
500

    
501
            case 4:
502
                if(m->b4ptr > 1) {
503
                    gcode = get_bits(gbc, 7);
504
                    m->b4_mant[0] = b4_mantissas[gcode][0];
505
                    m->b4_mant[1] = b4_mantissas[gcode][1];
506
                    m->b4ptr = 0;
507
                }
508
                coeffs[i] = m->b4_mant[m->b4ptr++];
509
                break;
510

    
511
            case 5:
512
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
513
                break;
514

    
515
            default: {
516
                /* asymmetric dequantization */
517
                int qlevel = quantization_tab[tbap];
518
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
519
                break;
520
            }
521
        }
522
        coeffs[i] >>= exps[i];
523
    }
524
}
525

    
526
/**
527
 * Remove random dithering from coefficients with zero-bit mantissas
528
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
529
 */
530
static void remove_dithering(AC3DecodeContext *s) {
531
    int ch, i;
532
    int end=0;
533
    int *coeffs;
534
    uint8_t *bap;
535

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

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

    
576
/**
577
 * Decode the transform coefficients.
578
 */
579
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
580
{
581
    int ch, end;
582
    int got_cplchan = 0;
583
    mant_groups m;
584

    
585
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
586

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

    
607
    /* zero the dithered coefficients for appropriate channels */
608
    remove_dithering(s);
609
}
610

    
611
/**
612
 * Stereo rematrixing.
613
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
614
 */
615
static void do_rematrixing(AC3DecodeContext *s)
616
{
617
    int bnd, i;
618
    int end, bndend;
619
    int tmp0, tmp1;
620

    
621
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
622

    
623
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
624
        if(s->rematrixing_flags[bnd]) {
625
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
626
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
627
                tmp0 = s->fixed_coeffs[1][i];
628
                tmp1 = s->fixed_coeffs[2][i];
629
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
630
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
631
            }
632
        }
633
    }
634
}
635

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

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

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

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

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

    
744
    n_subbands = end_subband - start_subband;
745

    
746
    /* decode band structure from bitstream or use default */
747
    if (!eac3 || get_bits1(gbc)) {
748
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
749
            band_struct[subbnd] = get_bits1(gbc);
750
        }
751
    } else if (!blk) {
752
        memcpy(band_struct,
753
               &default_band_struct[start_subband+1],
754
               n_subbands-1);
755
    }
756
    band_struct[n_subbands-1] = 0;
757

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

    
775
    /* set optional output params */
776
    if (num_bands)
777
        *num_bands = n_bands;
778
    if (band_sizes)
779
        memcpy(band_sizes, bnd_sz, n_bands);
780
}
781

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

    
796
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
797

    
798
    /* block switch flags */
799
    different_transforms = 0;
800
    if (s->block_switch_syntax) {
801
        for (ch = 1; ch <= fbw_channels; ch++) {
802
            s->block_switch[ch] = get_bits1(gbc);
803
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
804
                different_transforms = 1;
805
        }
806
    }
807

    
808
    /* dithering flags */
809
    if (s->dither_flag_syntax) {
810
        for (ch = 1; ch <= fbw_channels; ch++) {
811
            s->dither_flag[ch] = get_bits1(gbc);
812
        }
813
    }
814

    
815
    /* dynamic range */
816
    i = !(s->channel_mode);
817
    do {
818
        if(get_bits1(gbc)) {
819
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
820
                                  s->avctx->drc_scale)+1.0;
821
        } else if(blk == 0) {
822
            s->dynamic_range[i] = 1.0f;
823
        }
824
    } while(i--);
825

    
826
    /* spectral extension strategy */
827
    if (s->eac3 && (!blk || get_bits1(gbc))) {
828
        if (get_bits1(gbc)) {
829
            ff_log_missing_feature(s->avctx, "Spectral extension", 1);
830
            return -1;
831
        }
832
        /* TODO: parse spectral extension strategy info */
833
    }
834

    
835
    /* TODO: spectral extension coordinates */
836

    
837
    /* coupling strategy */
838
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
839
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
840
        if (!s->eac3)
841
            s->cpl_in_use[blk] = get_bits1(gbc);
842
        if (s->cpl_in_use[blk]) {
843
            /* coupling in use */
844
            int cpl_start_subband, cpl_end_subband;
845

    
846
            if (channel_mode < AC3_CHMODE_STEREO) {
847
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
848
                return -1;
849
            }
850

    
851
            /* check for enhanced coupling */
852
            if (s->eac3 && get_bits1(gbc)) {
853
                /* TODO: parse enhanced coupling strategy info */
854
                ff_log_missing_feature(s->avctx, "Enhanced coupling", 1);
855
                return -1;
856
            }
857

    
858
            /* determine which channels are coupled */
859
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
860
                s->channel_in_cpl[1] = 1;
861
                s->channel_in_cpl[2] = 1;
862
            } else {
863
                for (ch = 1; ch <= fbw_channels; ch++)
864
                    s->channel_in_cpl[ch] = get_bits1(gbc);
865
            }
866

    
867
            /* phase flags in use */
868
            if (channel_mode == AC3_CHMODE_STEREO)
869
                s->phase_flags_in_use = get_bits1(gbc);
870

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

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

    
906
    /* coupling coordinates */
907
    if (cpl_in_use) {
908
        int cpl_coords_exist = 0;
909

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

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

    
957
    /* exponent strategies for each channel */
958
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
959
        if (!s->eac3)
960
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
961
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
962
            bit_alloc_stages[ch] = 3;
963
    }
964

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

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

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

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

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

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

    
1068
    /* E-AC-3 to AC-3 converter SNR offset */
1069
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1070
        skip_bits(gbc, 10); // skip converter snr offset
1071
    }
1072

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

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

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

    
1156
    /* unused dummy data */
1157
    if (s->skip_syntax && get_bits1(gbc)) {
1158
        int skipl = get_bits(gbc, 9);
1159
        while(skipl--)
1160
            skip_bits(gbc, 8);
1161
    }
1162

    
1163
    /* unpack the transform coefficients
1164
       this also uncouples channels if coupling is in use. */
1165
    decode_transform_coeffs(s, blk);
1166

    
1167
    /* TODO: generate enhanced coupling coordinates and uncouple */
1168

    
1169
    /* TODO: apply spectral extension */
1170

    
1171
    /* recover coefficients if rematrixing is in use */
1172
    if(s->channel_mode == AC3_CHMODE_STEREO)
1173
        do_rematrixing(s);
1174

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

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

    
1200
        do_imdct(s, s->channels);
1201

    
1202
        if(downmix_output) {
1203
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1204
        }
1205
    } else {
1206
        if(downmix_output) {
1207
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1208
        }
1209

    
1210
        if(downmix_output && !s->downmixed) {
1211
            s->downmixed = 1;
1212
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1213
        }
1214

    
1215
        do_imdct(s, s->out_channels);
1216
    }
1217

    
1218
    return 0;
1219
}
1220

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

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

    
1245
    /* parse the syncinfo */
1246
    *data_size = 0;
1247
    err = parse_frame_header(s);
1248

    
1249
    /* check that reported frame size fits in input buffer */
1250
    if(s->frame_size > buf_size) {
1251
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1252
        err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1253
    }
1254

    
1255
    /* check for crc mismatch */
1256
    if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
1257
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1258
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1259
            err = AAC_AC3_PARSE_ERROR_CRC;
1260
        }
1261
    }
1262

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

    
1293
    /* if frame is ok, set audio parameters */
1294
    if (!err) {
1295
        avctx->sample_rate = s->sample_rate;
1296
        avctx->bit_rate = s->bit_rate;
1297

    
1298
        /* channel config */
1299
        s->out_channels = s->channels;
1300
        s->output_mode = s->channel_mode;
1301
        if(s->lfe_on)
1302
            s->output_mode |= AC3_OUTPUT_LFEON;
1303
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1304
                avctx->request_channels < s->channels) {
1305
            s->out_channels = avctx->request_channels;
1306
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1307
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1308
        }
1309
        avctx->channels = s->out_channels;
1310
        avctx->channel_layout = s->channel_layout;
1311

    
1312
        /* set downmixing coefficients if needed */
1313
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1314
                s->fbw_channels == s->out_channels)) {
1315
            set_downmix_coeffs(s);
1316
        }
1317
    } else if (!s->out_channels) {
1318
        s->out_channels = avctx->channels;
1319
        if(s->out_channels < s->channels)
1320
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1321
    }
1322

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

    
1339
/**
1340
 * Uninitialize the AC-3 decoder.
1341
 */
1342
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1343
{
1344
    AC3DecodeContext *s = avctx->priv_data;
1345
    ff_mdct_end(&s->imdct_512);
1346
    ff_mdct_end(&s->imdct_256);
1347

    
1348
    av_freep(&s->input_buffer);
1349

    
1350
    return 0;
1351
}
1352

    
1353
AVCodec ac3_decoder = {
1354
    .name = "ac3",
1355
    .type = CODEC_TYPE_AUDIO,
1356
    .id = CODEC_ID_AC3,
1357
    .priv_data_size = sizeof (AC3DecodeContext),
1358
    .init = ac3_decode_init,
1359
    .close = ac3_decode_end,
1360
    .decode = ac3_decode_frame,
1361
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1362
};
1363

    
1364
AVCodec eac3_decoder = {
1365
    .name = "eac3",
1366
    .type = CODEC_TYPE_AUDIO,
1367
    .id = CODEC_ID_EAC3,
1368
    .priv_data_size = sizeof (AC3DecodeContext),
1369
    .init = ac3_decode_init,
1370
    .close = ac3_decode_end,
1371
    .decode = ac3_decode_frame,
1372
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1373
};