Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ b5ec6383

History | View | Annotate | Download (51.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
    ff_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 scale value for float to int16 conversion */
199
    s->mul_bias = 32767.0f;
200

    
201
    /* allow downmixing to stereo or mono */
202
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
203
            avctx->request_channels < avctx->channels &&
204
            avctx->request_channels <= 2) {
205
        avctx->channels = avctx->request_channels;
206
    }
207
    s->downmixed = 1;
208

    
209
    /* allocate context input buffer */
210
    if (avctx->error_recognition >= FF_ER_CAREFUL) {
211
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
212
        if (!s->input_buffer)
213
            return AVERROR(ENOMEM);
214
    }
215

    
216
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
217
    return 0;
218
}
219

    
220
/**
221
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
222
 * GetBitContext within AC3DecodeContext must point to
223
 * the start of the synchronized AC-3 bitstream.
224
 */
225
static int ac3_parse_header(AC3DecodeContext *s)
226
{
227
    GetBitContext *gbc = &s->gbc;
228
    int i;
229

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

    
242
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
243

    
244
    /* skip the timecodes (or extra bitstream information for Alternate Syntax)
245
       TODO: read & use the xbsi1 downmix levels */
246
    if (get_bits1(gbc))
247
        skip_bits(gbc, 14); //skip timecode1 / xbsi1
248
    if (get_bits1(gbc))
249
        skip_bits(gbc, 14); //skip timecode2 / xbsi2
250

    
251
    /* skip additional bitstream info */
252
    if (get_bits1(gbc)) {
253
        i = get_bits(gbc, 6);
254
        do {
255
            skip_bits(gbc, 8);
256
        } while(i--);
257
    }
258

    
259
    return 0;
260
}
261

    
262
/**
263
 * Common function to parse AC-3 or E-AC-3 frame header
264
 */
265
static int parse_frame_header(AC3DecodeContext *s)
266
{
267
    AC3HeaderInfo hdr;
268
    int err;
269

    
270
    err = ff_ac3_parse_header(&s->gbc, &hdr);
271
    if(err)
272
        return err;
273

    
274
    /* get decoding parameters from header info */
275
    s->bit_alloc_params.sr_code     = hdr.sr_code;
276
    s->channel_mode                 = hdr.channel_mode;
277
    s->channel_layout               = hdr.channel_layout;
278
    s->lfe_on                       = hdr.lfe_on;
279
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
280
    s->sample_rate                  = hdr.sample_rate;
281
    s->bit_rate                     = hdr.bit_rate;
282
    s->channels                     = hdr.channels;
283
    s->fbw_channels                 = s->channels - s->lfe_on;
284
    s->lfe_ch                       = s->fbw_channels + 1;
285
    s->frame_size                   = hdr.frame_size;
286
    s->center_mix_level             = hdr.center_mix_level;
287
    s->surround_mix_level           = hdr.surround_mix_level;
288
    s->num_blocks                   = hdr.num_blocks;
289
    s->frame_type                   = hdr.frame_type;
290
    s->substreamid                  = hdr.substreamid;
291

    
292
    if(s->lfe_on) {
293
        s->start_freq[s->lfe_ch] = 0;
294
        s->end_freq[s->lfe_ch] = 7;
295
        s->num_exp_groups[s->lfe_ch] = 2;
296
        s->channel_in_cpl[s->lfe_ch] = 0;
297
    }
298

    
299
    if (hdr.bitstream_id <= 10) {
300
        s->eac3                  = 0;
301
        s->snr_offset_strategy   = 2;
302
        s->block_switch_syntax   = 1;
303
        s->dither_flag_syntax    = 1;
304
        s->bit_allocation_syntax = 1;
305
        s->fast_gain_syntax      = 0;
306
        s->first_cpl_leak        = 0;
307
        s->dba_syntax            = 1;
308
        s->skip_syntax           = 1;
309
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
310
        return ac3_parse_header(s);
311
    } else if (CONFIG_EAC3_DECODER) {
312
        s->eac3 = 1;
313
        return ff_eac3_parse_header(s);
314
    } else {
315
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
316
        return -1;
317
    }
318
}
319

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

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

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

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

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

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

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

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

    
411
    bin = s->start_freq[CPL_CH];
412
    for (band = 0; band < s->num_cpl_bands; band++) {
413
        int band_start = bin;
414
        int band_end = bin + s->cpl_band_sizes[band];
415
        for (ch = 1; ch <= s->fbw_channels; ch++) {
416
            if (s->channel_in_cpl[ch]) {
417
                int cpl_coord = s->cpl_coords[ch][band] << 5;
418
                for (bin = band_start; bin < band_end; bin++) {
419
                    s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
420
                }
421
                if (ch == 2 && s->phase_flags[band]) {
422
                    for (bin = band_start; bin < band_end; bin++)
423
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
424
                }
425
            }
426
        }
427
        bin = band_end;
428
    }
429
}
430

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

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

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

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

    
530
    for(ch=1; ch<=s->fbw_channels; ch++) {
531
        if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
532
            for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
533
                if(!s->bap[CPL_CH][i])
534
                    s->fixed_coeffs[ch][i] = 0;
535
            }
536
        }
537
    }
538
}
539

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

    
557
/**
558
 * Decode the transform coefficients.
559
 */
560
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
561
{
562
    int ch, end;
563
    int got_cplchan = 0;
564
    mant_groups m;
565

    
566
    m.b1 = m.b2 = m.b4 = 0;
567

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

    
588
    /* zero the dithered coefficients for appropriate channels */
589
    remove_dithering(s);
590
}
591

    
592
/**
593
 * Stereo rematrixing.
594
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
595
 */
596
static void do_rematrixing(AC3DecodeContext *s)
597
{
598
    int bnd, i;
599
    int end, bndend;
600

    
601
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
602

    
603
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
604
        if(s->rematrixing_flags[bnd]) {
605
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
606
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
607
                int tmp0 = s->fixed_coeffs[1][i];
608
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
609
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
610
            }
611
        }
612
    }
613
}
614

    
615
/**
616
 * Inverse MDCT Transform.
617
 * Convert frequency domain coefficients to time-domain audio samples.
618
 * reference: Section 7.9.4 Transformation Equations
619
 */
620
static inline void do_imdct(AC3DecodeContext *s, int channels)
621
{
622
    int ch;
623

    
624
    for (ch=1; ch<=channels; ch++) {
625
        if (s->block_switch[ch]) {
626
            int i;
627
            float *x = s->tmp_output+128;
628
            for(i=0; i<128; i++)
629
                x[i] = s->transform_coeffs[ch][2*i];
630
            ff_imdct_half(&s->imdct_256, s->tmp_output, x);
631
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 0, 128);
632
            for(i=0; i<128; i++)
633
                x[i] = s->transform_coeffs[ch][2*i+1];
634
            ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
635
        } else {
636
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
637
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 0, 128);
638
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
639
        }
640
    }
641
}
642

    
643
/**
644
 * Downmix the output to mono or stereo.
645
 */
646
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
647
{
648
    int i, j;
649
    float v0, v1;
650
    if(out_ch == 2) {
651
        for(i=0; i<len; i++) {
652
            v0 = v1 = 0.0f;
653
            for(j=0; j<in_ch; j++) {
654
                v0 += samples[j][i] * matrix[j][0];
655
                v1 += samples[j][i] * matrix[j][1];
656
            }
657
            samples[0][i] = v0;
658
            samples[1][i] = v1;
659
        }
660
    } else if(out_ch == 1) {
661
        for(i=0; i<len; i++) {
662
            v0 = 0.0f;
663
            for(j=0; j<in_ch; j++)
664
                v0 += samples[j][i] * matrix[j][0];
665
            samples[0][i] = v0;
666
        }
667
    }
668
}
669

    
670
/**
671
 * Upmix delay samples from stereo to original channel layout.
672
 */
673
static void ac3_upmix_delay(AC3DecodeContext *s)
674
{
675
    int channel_data_size = sizeof(s->delay[0]);
676
    switch(s->channel_mode) {
677
        case AC3_CHMODE_DUALMONO:
678
        case AC3_CHMODE_STEREO:
679
            /* upmix mono to stereo */
680
            memcpy(s->delay[1], s->delay[0], channel_data_size);
681
            break;
682
        case AC3_CHMODE_2F2R:
683
            memset(s->delay[3], 0, channel_data_size);
684
        case AC3_CHMODE_2F1R:
685
            memset(s->delay[2], 0, channel_data_size);
686
            break;
687
        case AC3_CHMODE_3F2R:
688
            memset(s->delay[4], 0, channel_data_size);
689
        case AC3_CHMODE_3F1R:
690
            memset(s->delay[3], 0, channel_data_size);
691
        case AC3_CHMODE_3F:
692
            memcpy(s->delay[2], s->delay[1], channel_data_size);
693
            memset(s->delay[1], 0, channel_data_size);
694
            break;
695
    }
696
}
697

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

    
724
    n_subbands = end_subband - start_subband;
725

    
726
    /* decode band structure from bitstream or use default */
727
    if (!eac3 || get_bits1(gbc)) {
728
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
729
            coded_band_struct[subbnd] = get_bits1(gbc);
730
        }
731
        band_struct = coded_band_struct;
732
    } else if (!blk) {
733
        band_struct = &default_band_struct[start_subband+1];
734
    } else {
735
        /* no change in band structure */
736
        return;
737
    }
738

    
739
    /* calculate number of bands and band sizes based on band structure.
740
       note that the first 4 subbands in enhanced coupling span only 6 bins
741
       instead of 12. */
742
    if (num_bands || band_sizes ) {
743
        n_bands = n_subbands;
744
        bnd_sz[0] = ecpl ? 6 : 12;
745
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
746
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
747
            if (band_struct[subbnd-1]) {
748
                n_bands--;
749
                bnd_sz[bnd] += subbnd_size;
750
            } else {
751
                bnd_sz[++bnd] = subbnd_size;
752
            }
753
        }
754
    }
755

    
756
    /* set optional output params */
757
    if (num_bands)
758
        *num_bands = n_bands;
759
    if (band_sizes)
760
        memcpy(band_sizes, bnd_sz, n_bands);
761
}
762

    
763
/**
764
 * Decode a single audio block from the AC-3 bitstream.
765
 */
766
static int decode_audio_block(AC3DecodeContext *s, int blk)
767
{
768
    int fbw_channels = s->fbw_channels;
769
    int channel_mode = s->channel_mode;
770
    int i, bnd, seg, ch;
771
    int different_transforms;
772
    int downmix_output;
773
    int cpl_in_use;
774
    GetBitContext *gbc = &s->gbc;
775
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
776

    
777
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
778

    
779
    /* block switch flags */
780
    different_transforms = 0;
781
    if (s->block_switch_syntax) {
782
        for (ch = 1; ch <= fbw_channels; ch++) {
783
            s->block_switch[ch] = get_bits1(gbc);
784
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
785
                different_transforms = 1;
786
        }
787
    }
788

    
789
    /* dithering flags */
790
    if (s->dither_flag_syntax) {
791
        for (ch = 1; ch <= fbw_channels; ch++) {
792
            s->dither_flag[ch] = get_bits1(gbc);
793
        }
794
    }
795

    
796
    /* dynamic range */
797
    i = !(s->channel_mode);
798
    do {
799
        if(get_bits1(gbc)) {
800
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
801
                                  s->avctx->drc_scale)+1.0;
802
        } else if(blk == 0) {
803
            s->dynamic_range[i] = 1.0f;
804
        }
805
    } while(i--);
806

    
807
    /* spectral extension strategy */
808
    if (s->eac3 && (!blk || get_bits1(gbc))) {
809
        s->spx_in_use = get_bits1(gbc);
810
        if (s->spx_in_use) {
811
            int dst_start_freq, dst_end_freq, src_start_freq,
812
                start_subband, end_subband;
813

    
814
            /* determine which channels use spx */
815
            if (s->channel_mode == AC3_CHMODE_MONO) {
816
                s->channel_uses_spx[1] = 1;
817
            } else {
818
                for (ch = 1; ch <= fbw_channels; ch++)
819
                    s->channel_uses_spx[ch] = get_bits1(gbc);
820
            }
821

    
822
            /* get the frequency bins of the spx copy region and the spx start
823
               and end subbands */
824
            dst_start_freq = get_bits(gbc, 2);
825
            start_subband  = get_bits(gbc, 3) + 2;
826
            if (start_subband > 7)
827
                start_subband += start_subband - 7;
828
            end_subband    = get_bits(gbc, 3) + 5;
829
            if (end_subband   > 7)
830
                end_subband   += end_subband   - 7;
831
            dst_start_freq = dst_start_freq * 12 + 25;
832
            src_start_freq = start_subband  * 12 + 25;
833
            dst_end_freq   = end_subband    * 12 + 25;
834

    
835
            /* check validity of spx ranges */
836
            if (start_subband >= end_subband) {
837
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
838
                       "range (%d >= %d)\n", start_subband, end_subband);
839
                return -1;
840
            }
841
            if (dst_start_freq >= src_start_freq) {
842
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
843
                       "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
844
                return -1;
845
            }
846

    
847
            s->spx_dst_start_freq = dst_start_freq;
848
            s->spx_src_start_freq = src_start_freq;
849
            s->spx_dst_end_freq   = dst_end_freq;
850

    
851
            decode_band_structure(gbc, blk, s->eac3, 0,
852
                                  start_subband, end_subband,
853
                                  ff_eac3_default_spx_band_struct,
854
                                  &s->num_spx_bands,
855
                                  s->spx_band_sizes);
856
        } else {
857
            for (ch = 1; ch <= fbw_channels; ch++) {
858
                s->channel_uses_spx[ch] = 0;
859
                s->first_spx_coords[ch] = 1;
860
            }
861
        }
862
    }
863

    
864
    /* spectral extension coordinates */
865
    if (s->spx_in_use) {
866
        for (ch = 1; ch <= fbw_channels; ch++) {
867
            if (s->channel_uses_spx[ch]) {
868
                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
869
                    float spx_blend;
870
                    int bin, master_spx_coord;
871

    
872
                    s->first_spx_coords[ch] = 0;
873
                    spx_blend = get_bits(gbc, 5) * (1.0f/32);
874
                    master_spx_coord = get_bits(gbc, 2) * 3;
875

    
876
                    bin = s->spx_src_start_freq;
877
                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
878
                        int bandsize;
879
                        int spx_coord_exp, spx_coord_mant;
880
                        float nratio, sblend, nblend, spx_coord;
881

    
882
                        /* calculate blending factors */
883
                        bandsize = s->spx_band_sizes[bnd];
884
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
885
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
886
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
887
                        sblend = sqrtf(1.0f - nratio);
888
                        bin += bandsize;
889

    
890
                        /* decode spx coordinates */
891
                        spx_coord_exp  = get_bits(gbc, 4);
892
                        spx_coord_mant = get_bits(gbc, 2);
893
                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
894
                        else                     spx_coord_mant += 4;
895
                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
896
                        spx_coord = spx_coord_mant * (1.0f/(1<<23));
897

    
898
                        /* multiply noise and signal blending factors by spx coordinate */
899
                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
900
                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
901
                    }
902
                }
903
            } else {
904
                s->first_spx_coords[ch] = 1;
905
            }
906
        }
907
    }
908

    
909
    /* coupling strategy */
910
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
911
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
912
        if (!s->eac3)
913
            s->cpl_in_use[blk] = get_bits1(gbc);
914
        if (s->cpl_in_use[blk]) {
915
            /* coupling in use */
916
            int cpl_start_subband, cpl_end_subband;
917

    
918
            if (channel_mode < AC3_CHMODE_STEREO) {
919
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
920
                return -1;
921
            }
922

    
923
            /* check for enhanced coupling */
924
            if (s->eac3 && get_bits1(gbc)) {
925
                /* TODO: parse enhanced coupling strategy info */
926
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
927
                return -1;
928
            }
929

    
930
            /* determine which channels are coupled */
931
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
932
                s->channel_in_cpl[1] = 1;
933
                s->channel_in_cpl[2] = 1;
934
            } else {
935
                for (ch = 1; ch <= fbw_channels; ch++)
936
                    s->channel_in_cpl[ch] = get_bits1(gbc);
937
            }
938

    
939
            /* phase flags in use */
940
            if (channel_mode == AC3_CHMODE_STEREO)
941
                s->phase_flags_in_use = get_bits1(gbc);
942

    
943
            /* coupling frequency range */
944
            cpl_start_subband = get_bits(gbc, 4);
945
            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
946
                                              get_bits(gbc, 4) + 3;
947
            if (cpl_start_subband >= cpl_end_subband) {
948
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
949
                       cpl_start_subband, cpl_end_subband);
950
                return -1;
951
            }
952
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
953
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
954

    
955
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
956
                                  cpl_end_subband,
957
                                  ff_eac3_default_cpl_band_struct,
958
                                  &s->num_cpl_bands, s->cpl_band_sizes);
959
        } else {
960
            /* coupling not in use */
961
            for (ch = 1; ch <= fbw_channels; ch++) {
962
                s->channel_in_cpl[ch] = 0;
963
                s->first_cpl_coords[ch] = 1;
964
            }
965
            s->first_cpl_leak = s->eac3;
966
            s->phase_flags_in_use = 0;
967
        }
968
    } else if (!s->eac3) {
969
        if(!blk) {
970
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
971
            return -1;
972
        } else {
973
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
974
        }
975
    }
976
    cpl_in_use = s->cpl_in_use[blk];
977

    
978
    /* coupling coordinates */
979
    if (cpl_in_use) {
980
        int cpl_coords_exist = 0;
981

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

    
1015
    /* stereo rematrixing strategy and band structure */
1016
    if (channel_mode == AC3_CHMODE_STEREO) {
1017
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1018
            s->num_rematrixing_bands = 4;
1019
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1020
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1021
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1022
                s->num_rematrixing_bands--;
1023
            }
1024
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
1025
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1026
        } else if (!blk) {
1027
            av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
1028
            s->num_rematrixing_bands = 0;
1029
        }
1030
    }
1031

    
1032
    /* exponent strategies for each channel */
1033
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1034
        if (!s->eac3)
1035
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1036
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
1037
            bit_alloc_stages[ch] = 3;
1038
    }
1039

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

    
1069
    /* decode exponents for each channel */
1070
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1071
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1072
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1073
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1074
                                 s->num_exp_groups[ch], s->dexps[ch][0],
1075
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1076
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1077
                return -1;
1078
            }
1079
            if(ch != CPL_CH && ch != s->lfe_ch)
1080
                skip_bits(gbc, 2); /* skip gainrng */
1081
        }
1082
    }
1083

    
1084
    /* bit allocation information */
1085
    if (s->bit_allocation_syntax) {
1086
        if (get_bits1(gbc)) {
1087
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1088
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1089
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1090
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1091
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1092
            for(ch=!cpl_in_use; ch<=s->channels; ch++)
1093
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1094
        } else if (!blk) {
1095
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1096
            return -1;
1097
        }
1098
    }
1099

    
1100
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1101
    if(!s->eac3 || !blk){
1102
        if(s->snr_offset_strategy && get_bits1(gbc)) {
1103
            int snr = 0;
1104
            int csnr;
1105
            csnr = (get_bits(gbc, 6) - 15) << 4;
1106
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1107
                /* snr offset */
1108
                if (ch == i || s->snr_offset_strategy == 2)
1109
                    snr = (csnr + get_bits(gbc, 4)) << 2;
1110
                /* run at least last bit allocation stage if snr offset changes */
1111
                if(blk && s->snr_offset[ch] != snr) {
1112
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1113
                }
1114
                s->snr_offset[ch] = snr;
1115

    
1116
                /* fast gain (normal AC-3 only) */
1117
                if (!s->eac3) {
1118
                    int prev = s->fast_gain[ch];
1119
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1120
                    /* run last 2 bit allocation stages if fast gain changes */
1121
                    if(blk && prev != s->fast_gain[ch])
1122
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1123
                }
1124
            }
1125
        } else if (!s->eac3 && !blk) {
1126
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1127
            return -1;
1128
        }
1129
    }
1130

    
1131
    /* fast gain (E-AC-3 only) */
1132
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1133
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1134
            int prev = s->fast_gain[ch];
1135
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1136
            /* run last 2 bit allocation stages if fast gain changes */
1137
            if(blk && prev != s->fast_gain[ch])
1138
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1139
        }
1140
    } else if (s->eac3 && !blk) {
1141
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1142
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1143
    }
1144

    
1145
    /* E-AC-3 to AC-3 converter SNR offset */
1146
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1147
        skip_bits(gbc, 10); // skip converter snr offset
1148
    }
1149

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

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

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

    
1233
    /* unused dummy data */
1234
    if (s->skip_syntax && get_bits1(gbc)) {
1235
        int skipl = get_bits(gbc, 9);
1236
        while(skipl--)
1237
            skip_bits(gbc, 8);
1238
    }
1239

    
1240
    /* unpack the transform coefficients
1241
       this also uncouples channels if coupling is in use. */
1242
    decode_transform_coeffs(s, blk);
1243

    
1244
    /* TODO: generate enhanced coupling coordinates and uncouple */
1245

    
1246
    /* recover coefficients if rematrixing is in use */
1247
    if(s->channel_mode == AC3_CHMODE_STEREO)
1248
        do_rematrixing(s);
1249

    
1250
    /* apply scaling to coefficients (headroom, dynrng) */
1251
    for(ch=1; ch<=s->channels; ch++) {
1252
        float gain = s->mul_bias / 4194304.0f;
1253
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1254
            gain *= s->dynamic_range[2-ch];
1255
        } else {
1256
            gain *= s->dynamic_range[0];
1257
        }
1258
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1259
    }
1260

    
1261
    /* apply spectral extension to high frequency bins */
1262
    if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1263
        ff_eac3_apply_spectral_extension(s);
1264
    }
1265

    
1266
    /* downmix and MDCT. order depends on whether block switching is used for
1267
       any channel in this block. this is because coefficients for the long
1268
       and short transforms cannot be mixed. */
1269
    downmix_output = s->channels != s->out_channels &&
1270
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1271
                     s->fbw_channels == s->out_channels);
1272
    if(different_transforms) {
1273
        /* the delay samples have already been downmixed, so we upmix the delay
1274
           samples in order to reconstruct all channels before downmixing. */
1275
        if(s->downmixed) {
1276
            s->downmixed = 0;
1277
            ac3_upmix_delay(s);
1278
        }
1279

    
1280
        do_imdct(s, s->channels);
1281

    
1282
        if(downmix_output) {
1283
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1284
        }
1285
    } else {
1286
        if(downmix_output) {
1287
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1288
        }
1289

    
1290
        if(downmix_output && !s->downmixed) {
1291
            s->downmixed = 1;
1292
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1293
        }
1294

    
1295
        do_imdct(s, s->out_channels);
1296
    }
1297

    
1298
    return 0;
1299
}
1300

    
1301
/**
1302
 * Decode a single AC-3 frame.
1303
 */
1304
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1305
                            AVPacket *avpkt)
1306
{
1307
    const uint8_t *buf = avpkt->data;
1308
    int buf_size = avpkt->size;
1309
    AC3DecodeContext *s = avctx->priv_data;
1310
    int16_t *out_samples = (int16_t *)data;
1311
    int blk, ch, err;
1312
    const uint8_t *channel_map;
1313
    const float *output[AC3_MAX_CHANNELS];
1314

    
1315
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1316
    if (s->input_buffer) {
1317
        /* copy input buffer to decoder context to avoid reading past the end
1318
           of the buffer, which can be caused by a damaged input stream. */
1319
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1320
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1321
    } else {
1322
        init_get_bits(&s->gbc, buf, buf_size * 8);
1323
    }
1324

    
1325
    /* parse the syncinfo */
1326
    *data_size = 0;
1327
    err = parse_frame_header(s);
1328

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

    
1371
    /* if frame is ok, set audio parameters */
1372
    if (!err) {
1373
        avctx->sample_rate = s->sample_rate;
1374
        avctx->bit_rate = s->bit_rate;
1375

    
1376
        /* channel config */
1377
        s->out_channels = s->channels;
1378
        s->output_mode = s->channel_mode;
1379
        if(s->lfe_on)
1380
            s->output_mode |= AC3_OUTPUT_LFEON;
1381
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1382
                avctx->request_channels < s->channels) {
1383
            s->out_channels = avctx->request_channels;
1384
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1385
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1386
        }
1387
        avctx->channels = s->out_channels;
1388
        avctx->channel_layout = s->channel_layout;
1389

    
1390
        /* set downmixing coefficients if needed */
1391
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1392
                s->fbw_channels == s->out_channels)) {
1393
            set_downmix_coeffs(s);
1394
        }
1395
    } else if (!s->out_channels) {
1396
        s->out_channels = avctx->channels;
1397
        if(s->out_channels < s->channels)
1398
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1399
    }
1400

    
1401
    /* decode the audio blocks */
1402
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1403
    for (ch = 0; ch < s->out_channels; ch++)
1404
        output[ch] = s->output[channel_map[ch]];
1405
    for (blk = 0; blk < s->num_blocks; blk++) {
1406
        if (!err && decode_audio_block(s, blk)) {
1407
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1408
            err = 1;
1409
        }
1410
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1411
        out_samples += 256 * s->out_channels;
1412
    }
1413
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1414
    return FFMIN(buf_size, s->frame_size);
1415
}
1416

    
1417
/**
1418
 * Uninitialize the AC-3 decoder.
1419
 */
1420
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1421
{
1422
    AC3DecodeContext *s = avctx->priv_data;
1423
    ff_mdct_end(&s->imdct_512);
1424
    ff_mdct_end(&s->imdct_256);
1425

    
1426
    av_freep(&s->input_buffer);
1427

    
1428
    return 0;
1429
}
1430

    
1431
AVCodec ff_ac3_decoder = {
1432
    .name = "ac3",
1433
    .type = AVMEDIA_TYPE_AUDIO,
1434
    .id = CODEC_ID_AC3,
1435
    .priv_data_size = sizeof (AC3DecodeContext),
1436
    .init = ac3_decode_init,
1437
    .close = ac3_decode_end,
1438
    .decode = ac3_decode_frame,
1439
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1440
};
1441

    
1442
#if CONFIG_EAC3_DECODER
1443
AVCodec ff_eac3_decoder = {
1444
    .name = "eac3",
1445
    .type = AVMEDIA_TYPE_AUDIO,
1446
    .id = CODEC_ID_EAC3,
1447
    .priv_data_size = sizeof (AC3DecodeContext),
1448
    .init = ac3_decode_init,
1449
    .close = ac3_decode_end,
1450
    .decode = ac3_decode_frame,
1451
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1452
};
1453
#endif