Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 3fdccca0

History | View | Annotate | Download (47.9 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 if (CONFIG_EAC3_DECODER) {
318
        s->eac3 = 1;
319
        return ff_eac3_parse_header(s);
320
    } else {
321
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
322
        return -1;
323
    }
324
}
325

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

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

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

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

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

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

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

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

    
417
    bin = s->start_freq[CPL_CH];
418
    for (band = 0; band < s->num_cpl_bands; band++) {
419
        int band_start = bin;
420
        int band_end = bin + s->cpl_band_sizes[band];
421
        for (ch = 1; ch <= s->fbw_channels; ch++) {
422
            if (s->channel_in_cpl[ch]) {
423
                int64_t cpl_coord = s->cpl_coords[ch][band];
424
                for (bin = band_start; bin < band_end; bin++) {
425
                    s->fixed_coeffs[ch][bin] = ((int64_t)s->fixed_coeffs[CPL_CH][bin] *
426
                                                cpl_coord) >> 23;
427
                }
428
                if (ch == 2 && s->phase_flags[band]) {
429
                    for (bin = band_start; bin < band_end; bin++)
430
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
431
                }
432
            }
433
        }
434
        bin = band_end;
435
    }
436
}
437

    
438
/**
439
 * Grouped mantissas for 3-level 5-level and 11-level quantization
440
 */
441
typedef struct {
442
    int b1_mant[2];
443
    int b2_mant[2];
444
    int b4_mant;
445
    int b1;
446
    int b2;
447
    int b4;
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
    int start_freq = s->start_freq[ch_index];
457
    int end_freq = s->end_freq[ch_index];
458
    uint8_t *baps = s->bap[ch_index];
459
    int8_t *exps = s->dexps[ch_index];
460
    int *coeffs = s->fixed_coeffs[ch_index];
461
    int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
462
    GetBitContext *gbc = &s->gbc;
463
    int freq;
464

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

    
529
/**
530
 * Remove random dithering from coupling range coefficients with zero-bit
531
 * mantissas for coupled channels which do not use dithering.
532
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
533
 */
534
static void remove_dithering(AC3DecodeContext *s) {
535
    int ch, i;
536

    
537
    for(ch=1; ch<=s->fbw_channels; ch++) {
538
        if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
539
            for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
540
                if(!s->bap[CPL_CH][i])
541
                    s->fixed_coeffs[ch][i] = 0;
542
            }
543
        }
544
    }
545
}
546

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

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

    
573
    m.b1 = m.b2 = m.b4 = 0;
574

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

    
595
    /* zero the dithered coefficients for appropriate channels */
596
    remove_dithering(s);
597
}
598

    
599
/**
600
 * Stereo rematrixing.
601
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
602
 */
603
static void do_rematrixing(AC3DecodeContext *s)
604
{
605
    int bnd, i;
606
    int end, bndend;
607

    
608
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
609

    
610
    i = ff_ac3_rematrix_band_tab[0];
611
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
612
        if(s->rematrixing_flags[bnd]) {
613
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
614
            for(; i<bndend; i++) {
615
                int tmp0 = s->fixed_coeffs[1][i];
616
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
617
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
618
            }
619
        }
620
    }
621
}
622

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

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

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

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

    
709
/**
710
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
711
 * The band structure defines how many subbands are in each band.  For each
712
 * subband in the range, 1 means it is combined with the previous band, and 0
713
 * means that it starts a new band.
714
 *
715
 * @param[in] gbc bit reader context
716
 * @param[in] blk block number
717
 * @param[in] eac3 flag to indicate E-AC-3
718
 * @param[in] ecpl flag to indicate enhanced coupling
719
 * @param[in] start_subband subband number for start of range
720
 * @param[in] end_subband subband number for end of range
721
 * @param[in] default_band_struct default band structure table
722
 * @param[out] num_bands number of bands (optionally NULL)
723
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
724
 */
725
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
726
                                  int ecpl, int start_subband, int end_subband,
727
                                  const uint8_t *default_band_struct,
728
                                  int *num_bands, uint8_t *band_sizes)
729
{
730
    int subbnd, bnd, n_subbands, n_bands=0;
731
    uint8_t bnd_sz[22];
732
    uint8_t coded_band_struct[22];
733
    const uint8_t *band_struct;
734

    
735
    n_subbands = end_subband - start_subband;
736

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

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

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

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

    
788
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
789

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

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

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

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

    
827
    /* TODO: spectral extension coordinates */
828

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1159
    /* TODO: generate enhanced coupling coordinates and uncouple */
1160

    
1161
    /* TODO: apply spectral extension */
1162

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

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

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

    
1192
        do_imdct(s, s->channels);
1193

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

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

    
1207
        do_imdct(s, s->out_channels);
1208
    }
1209

    
1210
    return 0;
1211
}
1212

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

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

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

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

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

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

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

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

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

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

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

    
1340
    av_freep(&s->input_buffer);
1341

    
1342
    return 0;
1343
}
1344

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

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