Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 72415b2a

History | View | Annotate | Download (52.2 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
                int cpl_coord = s->cpl_coords[ch][band] << 5;
424
                for (bin = band_start; bin < band_end; bin++) {
425
                    s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
426
                }
427
                if (ch == 2 && s->phase_flags[band]) {
428
                    for (bin = band_start; bin < band_end; bin++)
429
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
430
                }
431
            }
432
        }
433
        bin = band_end;
434
    }
435
}
436

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
733
    n_subbands = end_subband - start_subband;
734

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

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

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

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

    
786
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
787

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

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

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

    
816
    /* spectral extension strategy */
817
    if (s->eac3 && (!blk || get_bits1(gbc))) {
818
        s->spx_in_use = get_bits1(gbc);
819
        if (s->spx_in_use) {
820
            int dst_start_freq, dst_end_freq, src_start_freq,
821
                start_subband, end_subband;
822

    
823
            /* determine which channels use spx */
824
            if (s->channel_mode == AC3_CHMODE_MONO) {
825
                s->channel_uses_spx[1] = 1;
826
            } else {
827
                for (ch = 1; ch <= fbw_channels; ch++)
828
                    s->channel_uses_spx[ch] = get_bits1(gbc);
829
            }
830

    
831
            /* get the frequency bins of the spx copy region and the spx start
832
               and end subbands */
833
            dst_start_freq = get_bits(gbc, 2);
834
            start_subband  = get_bits(gbc, 3) + 2;
835
            if (start_subband > 7)
836
                start_subband += start_subband - 7;
837
            end_subband    = get_bits(gbc, 3) + 5;
838
            if (end_subband   > 7)
839
                end_subband   += end_subband   - 7;
840
            dst_start_freq = dst_start_freq * 12 + 25;
841
            src_start_freq = start_subband  * 12 + 25;
842
            dst_end_freq   = end_subband    * 12 + 25;
843

    
844
            /* check validity of spx ranges */
845
            if (start_subband >= end_subband) {
846
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
847
                       "range (%d >= %d)\n", start_subband, end_subband);
848
                return -1;
849
            }
850
            if (dst_start_freq >= src_start_freq) {
851
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
852
                       "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
853
                return -1;
854
            }
855

    
856
            s->spx_dst_start_freq = dst_start_freq;
857
            s->spx_src_start_freq = src_start_freq;
858
            s->spx_dst_end_freq   = dst_end_freq;
859

    
860
            decode_band_structure(gbc, blk, s->eac3, 0,
861
                                  start_subband, end_subband,
862
                                  ff_eac3_default_spx_band_struct,
863
                                  &s->num_spx_bands,
864
                                  s->spx_band_sizes);
865
        } else {
866
            for (ch = 1; ch <= fbw_channels; ch++) {
867
                s->channel_uses_spx[ch] = 0;
868
                s->first_spx_coords[ch] = 1;
869
            }
870
        }
871
    }
872

    
873
    /* spectral extension coordinates */
874
    if (s->spx_in_use) {
875
        for (ch = 1; ch <= fbw_channels; ch++) {
876
            if (s->channel_uses_spx[ch]) {
877
                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
878
                    float spx_blend;
879
                    int bin, master_spx_coord;
880

    
881
                    s->first_spx_coords[ch] = 0;
882
                    spx_blend = get_bits(gbc, 5) * (1.0f/32);
883
                    master_spx_coord = get_bits(gbc, 2) * 3;
884

    
885
                    bin = s->spx_src_start_freq;
886
                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
887
                        int bandsize;
888
                        int spx_coord_exp, spx_coord_mant;
889
                        float nratio, sblend, nblend, spx_coord;
890

    
891
                        /* calculate blending factors */
892
                        bandsize = s->spx_band_sizes[bnd];
893
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
894
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
895
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
896
                        sblend = sqrtf(1.0f - nratio);
897
                        bin += bandsize;
898

    
899
                        /* decode spx coordinates */
900
                        spx_coord_exp  = get_bits(gbc, 4);
901
                        spx_coord_mant = get_bits(gbc, 2);
902
                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
903
                        else                     spx_coord_mant += 4;
904
                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
905
                        spx_coord = spx_coord_mant * (1.0f/(1<<23));
906

    
907
                        /* multiply noise and signal blending factors by spx coordinate */
908
                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
909
                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
910
                    }
911
                }
912
            } else {
913
                s->first_spx_coords[ch] = 1;
914
            }
915
        }
916
    }
917

    
918
    /* coupling strategy */
919
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
920
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
921
        if (!s->eac3)
922
            s->cpl_in_use[blk] = get_bits1(gbc);
923
        if (s->cpl_in_use[blk]) {
924
            /* coupling in use */
925
            int cpl_start_subband, cpl_end_subband;
926

    
927
            if (channel_mode < AC3_CHMODE_STEREO) {
928
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
929
                return -1;
930
            }
931

    
932
            /* check for enhanced coupling */
933
            if (s->eac3 && get_bits1(gbc)) {
934
                /* TODO: parse enhanced coupling strategy info */
935
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
936
                return -1;
937
            }
938

    
939
            /* determine which channels are coupled */
940
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
941
                s->channel_in_cpl[1] = 1;
942
                s->channel_in_cpl[2] = 1;
943
            } else {
944
                for (ch = 1; ch <= fbw_channels; ch++)
945
                    s->channel_in_cpl[ch] = get_bits1(gbc);
946
            }
947

    
948
            /* phase flags in use */
949
            if (channel_mode == AC3_CHMODE_STEREO)
950
                s->phase_flags_in_use = get_bits1(gbc);
951

    
952
            /* coupling frequency range */
953
            cpl_start_subband = get_bits(gbc, 4);
954
            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
955
                                              get_bits(gbc, 4) + 3;
956
            if (cpl_start_subband >= cpl_end_subband) {
957
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
958
                       cpl_start_subband, cpl_end_subband);
959
                return -1;
960
            }
961
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
962
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
963

    
964
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
965
                                  cpl_end_subband,
966
                                  ff_eac3_default_cpl_band_struct,
967
                                  &s->num_cpl_bands, s->cpl_band_sizes);
968
        } else {
969
            /* coupling not in use */
970
            for (ch = 1; ch <= fbw_channels; ch++) {
971
                s->channel_in_cpl[ch] = 0;
972
                s->first_cpl_coords[ch] = 1;
973
            }
974
            s->first_cpl_leak = s->eac3;
975
            s->phase_flags_in_use = 0;
976
        }
977
    } else if (!s->eac3) {
978
        if(!blk) {
979
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
980
            return -1;
981
        } else {
982
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
983
        }
984
    }
985
    cpl_in_use = s->cpl_in_use[blk];
986

    
987
    /* coupling coordinates */
988
    if (cpl_in_use) {
989
        int cpl_coords_exist = 0;
990

    
991
        for (ch = 1; ch <= fbw_channels; ch++) {
992
            if (s->channel_in_cpl[ch]) {
993
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
994
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
995
                    s->first_cpl_coords[ch] = 0;
996
                    cpl_coords_exist = 1;
997
                    master_cpl_coord = 3 * get_bits(gbc, 2);
998
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
999
                        cpl_coord_exp = get_bits(gbc, 4);
1000
                        cpl_coord_mant = get_bits(gbc, 4);
1001
                        if (cpl_coord_exp == 15)
1002
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1003
                        else
1004
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1005
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1006
                    }
1007
                } else if (!blk) {
1008
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
1009
                    return -1;
1010
                }
1011
            } else {
1012
                /* channel not in coupling */
1013
                s->first_cpl_coords[ch] = 1;
1014
            }
1015
        }
1016
        /* phase flags */
1017
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1018
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1019
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1020
            }
1021
        }
1022
    }
1023

    
1024
    /* stereo rematrixing strategy and band structure */
1025
    if (channel_mode == AC3_CHMODE_STEREO) {
1026
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1027
            s->num_rematrixing_bands = 4;
1028
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1029
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1030
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1031
                s->num_rematrixing_bands--;
1032
            }
1033
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
1034
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1035
        } else if (!blk) {
1036
            av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
1037
            s->num_rematrixing_bands = 0;
1038
        }
1039
    }
1040

    
1041
    /* exponent strategies for each channel */
1042
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1043
        if (!s->eac3)
1044
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1045
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
1046
            bit_alloc_stages[ch] = 3;
1047
    }
1048

    
1049
    /* channel bandwidth */
1050
    for (ch = 1; ch <= fbw_channels; ch++) {
1051
        s->start_freq[ch] = 0;
1052
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1053
            int group_size;
1054
            int prev = s->end_freq[ch];
1055
            if (s->channel_in_cpl[ch])
1056
                s->end_freq[ch] = s->start_freq[CPL_CH];
1057
            else if (s->channel_uses_spx[ch])
1058
                s->end_freq[ch] = s->spx_src_start_freq;
1059
            else {
1060
                int bandwidth_code = get_bits(gbc, 6);
1061
                if (bandwidth_code > 60) {
1062
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1063
                    return -1;
1064
                }
1065
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1066
            }
1067
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1068
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
1069
            if(blk > 0 && s->end_freq[ch] != prev)
1070
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1071
        }
1072
    }
1073
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1074
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1075
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1076
    }
1077

    
1078
    /* decode exponents for each channel */
1079
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1080
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1081
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1082
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1083
                                 s->num_exp_groups[ch], s->dexps[ch][0],
1084
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1085
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1086
                return -1;
1087
            }
1088
            if(ch != CPL_CH && ch != s->lfe_ch)
1089
                skip_bits(gbc, 2); /* skip gainrng */
1090
        }
1091
    }
1092

    
1093
    /* bit allocation information */
1094
    if (s->bit_allocation_syntax) {
1095
        if (get_bits1(gbc)) {
1096
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1097
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1098
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1099
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1100
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1101
            for(ch=!cpl_in_use; ch<=s->channels; ch++)
1102
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1103
        } else if (!blk) {
1104
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1105
            return -1;
1106
        }
1107
    }
1108

    
1109
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1110
    if(!s->eac3 || !blk){
1111
        if(s->snr_offset_strategy && get_bits1(gbc)) {
1112
            int snr = 0;
1113
            int csnr;
1114
            csnr = (get_bits(gbc, 6) - 15) << 4;
1115
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1116
                /* snr offset */
1117
                if (ch == i || s->snr_offset_strategy == 2)
1118
                    snr = (csnr + get_bits(gbc, 4)) << 2;
1119
                /* run at least last bit allocation stage if snr offset changes */
1120
                if(blk && s->snr_offset[ch] != snr) {
1121
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1122
                }
1123
                s->snr_offset[ch] = snr;
1124

    
1125
                /* fast gain (normal AC-3 only) */
1126
                if (!s->eac3) {
1127
                    int prev = s->fast_gain[ch];
1128
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1129
                    /* run last 2 bit allocation stages if fast gain changes */
1130
                    if(blk && prev != s->fast_gain[ch])
1131
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1132
                }
1133
            }
1134
        } else if (!s->eac3 && !blk) {
1135
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1136
            return -1;
1137
        }
1138
    }
1139

    
1140
    /* fast gain (E-AC-3 only) */
1141
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1142
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1143
            int prev = s->fast_gain[ch];
1144
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1145
            /* run last 2 bit allocation stages if fast gain changes */
1146
            if(blk && prev != s->fast_gain[ch])
1147
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1148
        }
1149
    } else if (s->eac3 && !blk) {
1150
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1151
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1152
    }
1153

    
1154
    /* E-AC-3 to AC-3 converter SNR offset */
1155
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1156
        skip_bits(gbc, 10); // skip converter snr offset
1157
    }
1158

    
1159
    /* coupling leak information */
1160
    if (cpl_in_use) {
1161
        if (s->first_cpl_leak || get_bits1(gbc)) {
1162
            int fl = get_bits(gbc, 3);
1163
            int sl = get_bits(gbc, 3);
1164
            /* run last 2 bit allocation stages for coupling channel if
1165
               coupling leak changes */
1166
            if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1167
                       sl != s->bit_alloc_params.cpl_slow_leak)) {
1168
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1169
            }
1170
            s->bit_alloc_params.cpl_fast_leak = fl;
1171
            s->bit_alloc_params.cpl_slow_leak = sl;
1172
        } else if (!s->eac3 && !blk) {
1173
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1174
            return -1;
1175
        }
1176
        s->first_cpl_leak = 0;
1177
    }
1178

    
1179
    /* delta bit allocation information */
1180
    if (s->dba_syntax && get_bits1(gbc)) {
1181
        /* delta bit allocation exists (strategy) */
1182
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1183
            s->dba_mode[ch] = get_bits(gbc, 2);
1184
            if (s->dba_mode[ch] == DBA_RESERVED) {
1185
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1186
                return -1;
1187
            }
1188
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1189
        }
1190
        /* channel delta offset, len and bit allocation */
1191
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1192
            if (s->dba_mode[ch] == DBA_NEW) {
1193
                s->dba_nsegs[ch] = get_bits(gbc, 3);
1194
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1195
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1196
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1197
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1198
                }
1199
                /* run last 2 bit allocation stages if new dba values */
1200
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1201
            }
1202
        }
1203
    } else if(blk == 0) {
1204
        for(ch=0; ch<=s->channels; ch++) {
1205
            s->dba_mode[ch] = DBA_NONE;
1206
        }
1207
    }
1208

    
1209
    /* Bit allocation */
1210
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1211
        if(bit_alloc_stages[ch] > 2) {
1212
            /* Exponent mapping into PSD and PSD integration */
1213
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1214
                                      s->start_freq[ch], s->end_freq[ch],
1215
                                      s->psd[ch], s->band_psd[ch]);
1216
        }
1217
        if(bit_alloc_stages[ch] > 1) {
1218
            /* Compute excitation function, Compute masking curve, and
1219
               Apply delta bit allocation */
1220
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1221
                                           s->start_freq[ch], s->end_freq[ch],
1222
                                           s->fast_gain[ch], (ch == s->lfe_ch),
1223
                                           s->dba_mode[ch], s->dba_nsegs[ch],
1224
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1225
                                           s->dba_values[ch], s->mask[ch])) {
1226
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1227
                return -1;
1228
            }
1229
        }
1230
        if(bit_alloc_stages[ch] > 0) {
1231
            /* Compute bit allocation */
1232
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1233
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1234
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1235
                                      s->start_freq[ch], s->end_freq[ch],
1236
                                      s->snr_offset[ch],
1237
                                      s->bit_alloc_params.floor,
1238
                                      bap_tab, s->bap[ch]);
1239
        }
1240
    }
1241

    
1242
    /* unused dummy data */
1243
    if (s->skip_syntax && get_bits1(gbc)) {
1244
        int skipl = get_bits(gbc, 9);
1245
        while(skipl--)
1246
            skip_bits(gbc, 8);
1247
    }
1248

    
1249
    /* unpack the transform coefficients
1250
       this also uncouples channels if coupling is in use. */
1251
    decode_transform_coeffs(s, blk);
1252

    
1253
    /* TODO: generate enhanced coupling coordinates and uncouple */
1254

    
1255
    /* recover coefficients if rematrixing is in use */
1256
    if(s->channel_mode == AC3_CHMODE_STEREO)
1257
        do_rematrixing(s);
1258

    
1259
    /* apply scaling to coefficients (headroom, dynrng) */
1260
    for(ch=1; ch<=s->channels; ch++) {
1261
        float gain = s->mul_bias / 4194304.0f;
1262
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1263
            gain *= s->dynamic_range[2-ch];
1264
        } else {
1265
            gain *= s->dynamic_range[0];
1266
        }
1267
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1268
    }
1269

    
1270
    /* apply spectral extension to high frequency bins */
1271
    if (s->spx_in_use) {
1272
        ff_eac3_apply_spectral_extension(s);
1273
    }
1274

    
1275
    /* downmix and MDCT. order depends on whether block switching is used for
1276
       any channel in this block. this is because coefficients for the long
1277
       and short transforms cannot be mixed. */
1278
    downmix_output = s->channels != s->out_channels &&
1279
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1280
                     s->fbw_channels == s->out_channels);
1281
    if(different_transforms) {
1282
        /* the delay samples have already been downmixed, so we upmix the delay
1283
           samples in order to reconstruct all channels before downmixing. */
1284
        if(s->downmixed) {
1285
            s->downmixed = 0;
1286
            ac3_upmix_delay(s);
1287
        }
1288

    
1289
        do_imdct(s, s->channels);
1290

    
1291
        if(downmix_output) {
1292
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1293
        }
1294
    } else {
1295
        if(downmix_output) {
1296
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1297
        }
1298

    
1299
        if(downmix_output && !s->downmixed) {
1300
            s->downmixed = 1;
1301
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1302
        }
1303

    
1304
        do_imdct(s, s->out_channels);
1305
    }
1306

    
1307
    return 0;
1308
}
1309

    
1310
/**
1311
 * Decode a single AC-3 frame.
1312
 */
1313
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1314
                            AVPacket *avpkt)
1315
{
1316
    const uint8_t *buf = avpkt->data;
1317
    int buf_size = avpkt->size;
1318
    AC3DecodeContext *s = avctx->priv_data;
1319
    int16_t *out_samples = (int16_t *)data;
1320
    int blk, ch, err;
1321
    const uint8_t *channel_map;
1322
    const float *output[AC3_MAX_CHANNELS];
1323

    
1324
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1325
    if (s->input_buffer) {
1326
        /* copy input buffer to decoder context to avoid reading past the end
1327
           of the buffer, which can be caused by a damaged input stream. */
1328
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1329
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1330
    } else {
1331
        init_get_bits(&s->gbc, buf, buf_size * 8);
1332
    }
1333

    
1334
    /* parse the syncinfo */
1335
    *data_size = 0;
1336
    err = parse_frame_header(s);
1337

    
1338
    if (err) {
1339
        switch(err) {
1340
            case AAC_AC3_PARSE_ERROR_SYNC:
1341
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1342
                return -1;
1343
            case AAC_AC3_PARSE_ERROR_BSID:
1344
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1345
                break;
1346
            case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1347
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1348
                break;
1349
            case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1350
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1351
                break;
1352
            case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1353
                /* skip frame if CRC is ok. otherwise use error concealment. */
1354
                /* TODO: add support for substreams and dependent frames */
1355
                if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1356
                    av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1357
                    return s->frame_size;
1358
                } else {
1359
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1360
                }
1361
                break;
1362
            default:
1363
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1364
                break;
1365
        }
1366
    } else {
1367
        /* check that reported frame size fits in input buffer */
1368
        if (s->frame_size > buf_size) {
1369
            av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1370
            err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1371
        } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
1372
            /* check for crc mismatch */
1373
            if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1374
                av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1375
                err = AAC_AC3_PARSE_ERROR_CRC;
1376
            }
1377
        }
1378
    }
1379

    
1380
    /* if frame is ok, set audio parameters */
1381
    if (!err) {
1382
        avctx->sample_rate = s->sample_rate;
1383
        avctx->bit_rate = s->bit_rate;
1384

    
1385
        /* channel config */
1386
        s->out_channels = s->channels;
1387
        s->output_mode = s->channel_mode;
1388
        if(s->lfe_on)
1389
            s->output_mode |= AC3_OUTPUT_LFEON;
1390
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1391
                avctx->request_channels < s->channels) {
1392
            s->out_channels = avctx->request_channels;
1393
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1394
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1395
        }
1396
        avctx->channels = s->out_channels;
1397
        avctx->channel_layout = s->channel_layout;
1398

    
1399
        /* set downmixing coefficients if needed */
1400
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1401
                s->fbw_channels == s->out_channels)) {
1402
            set_downmix_coeffs(s);
1403
        }
1404
    } else if (!s->out_channels) {
1405
        s->out_channels = avctx->channels;
1406
        if(s->out_channels < s->channels)
1407
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1408
    }
1409

    
1410
    /* decode the audio blocks */
1411
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1412
    for (ch = 0; ch < s->out_channels; ch++)
1413
        output[ch] = s->output[channel_map[ch]];
1414
    for (blk = 0; blk < s->num_blocks; blk++) {
1415
        if (!err && decode_audio_block(s, blk)) {
1416
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1417
            err = 1;
1418
        }
1419
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1420
        out_samples += 256 * s->out_channels;
1421
    }
1422
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1423
    return s->frame_size;
1424
}
1425

    
1426
/**
1427
 * Uninitialize the AC-3 decoder.
1428
 */
1429
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1430
{
1431
    AC3DecodeContext *s = avctx->priv_data;
1432
    ff_mdct_end(&s->imdct_512);
1433
    ff_mdct_end(&s->imdct_256);
1434

    
1435
    av_freep(&s->input_buffer);
1436

    
1437
    return 0;
1438
}
1439

    
1440
AVCodec ac3_decoder = {
1441
    .name = "ac3",
1442
    .type = AVMEDIA_TYPE_AUDIO,
1443
    .id = CODEC_ID_AC3,
1444
    .priv_data_size = sizeof (AC3DecodeContext),
1445
    .init = ac3_decode_init,
1446
    .close = ac3_decode_end,
1447
    .decode = ac3_decode_frame,
1448
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1449
};
1450

    
1451
#if CONFIG_EAC3_DECODER
1452
AVCodec eac3_decoder = {
1453
    .name = "eac3",
1454
    .type = AVMEDIA_TYPE_AUDIO,
1455
    .id = CODEC_ID_EAC3,
1456
    .priv_data_size = sizeof (AC3DecodeContext),
1457
    .init = ac3_decode_init,
1458
    .close = ac3_decode_end,
1459
    .decode = ac3_decode_frame,
1460
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1461
};
1462
#endif