Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 6820008a

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
    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
    ff_fmt_convert_init(&s->fmt_conv, avctx);
197
    av_lfg_init(&s->dith_state, 0);
198

    
199
    /* set scale value for float to int16 conversion */
200
    s->mul_bias = 32767.0f;
201

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

    
210
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
211
    return 0;
212
}
213

    
214
/**
215
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
216
 * GetBitContext within AC3DecodeContext must point to
217
 * the start of the synchronized AC-3 bitstream.
218
 */
219
static int ac3_parse_header(AC3DecodeContext *s)
220
{
221
    GetBitContext *gbc = &s->gbc;
222
    int i;
223

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

    
236
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
237

    
238
    /* skip the timecodes (or extra bitstream information for Alternate Syntax)
239
       TODO: read & use the xbsi1 downmix levels */
240
    if (get_bits1(gbc))
241
        skip_bits(gbc, 14); //skip timecode1 / xbsi1
242
    if (get_bits1(gbc))
243
        skip_bits(gbc, 14); //skip timecode2 / xbsi2
244

    
245
    /* skip additional bitstream info */
246
    if (get_bits1(gbc)) {
247
        i = get_bits(gbc, 6);
248
        do {
249
            skip_bits(gbc, 8);
250
        } while(i--);
251
    }
252

    
253
    return 0;
254
}
255

    
256
/**
257
 * Common function to parse AC-3 or E-AC-3 frame header
258
 */
259
static int parse_frame_header(AC3DecodeContext *s)
260
{
261
    AC3HeaderInfo hdr;
262
    int err;
263

    
264
    err = ff_ac3_parse_header(&s->gbc, &hdr);
265
    if(err)
266
        return err;
267

    
268
    /* get decoding parameters from header info */
269
    s->bit_alloc_params.sr_code     = hdr.sr_code;
270
    s->channel_mode                 = hdr.channel_mode;
271
    s->channel_layout               = hdr.channel_layout;
272
    s->lfe_on                       = hdr.lfe_on;
273
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
274
    s->sample_rate                  = hdr.sample_rate;
275
    s->bit_rate                     = hdr.bit_rate;
276
    s->channels                     = hdr.channels;
277
    s->fbw_channels                 = s->channels - s->lfe_on;
278
    s->lfe_ch                       = s->fbw_channels + 1;
279
    s->frame_size                   = hdr.frame_size;
280
    s->center_mix_level             = hdr.center_mix_level;
281
    s->surround_mix_level           = hdr.surround_mix_level;
282
    s->num_blocks                   = hdr.num_blocks;
283
    s->frame_type                   = hdr.frame_type;
284
    s->substreamid                  = hdr.substreamid;
285

    
286
    if(s->lfe_on) {
287
        s->start_freq[s->lfe_ch] = 0;
288
        s->end_freq[s->lfe_ch] = 7;
289
        s->num_exp_groups[s->lfe_ch] = 2;
290
        s->channel_in_cpl[s->lfe_ch] = 0;
291
    }
292

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

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

    
325
    for(i=0; i<s->fbw_channels; i++) {
326
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
327
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
328
    }
329
    if(s->channel_mode > 1 && s->channel_mode & 1) {
330
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
331
    }
332
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
333
        int nf = s->channel_mode - 2;
334
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
335
    }
336
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
337
        int nf = s->channel_mode - 4;
338
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
339
    }
340

    
341
    /* renormalize */
342
    norm0 = norm1 = 0.0;
343
    for(i=0; i<s->fbw_channels; i++) {
344
        norm0 += s->downmix_coeffs[i][0];
345
        norm1 += s->downmix_coeffs[i][1];
346
    }
347
    norm0 = 1.0f / norm0;
348
    norm1 = 1.0f / norm1;
349
    for(i=0; i<s->fbw_channels; i++) {
350
        s->downmix_coeffs[i][0] *= norm0;
351
        s->downmix_coeffs[i][1] *= norm1;
352
    }
353

    
354
    if(s->output_mode == AC3_CHMODE_MONO) {
355
        for(i=0; i<s->fbw_channels; i++)
356
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
357
    }
358
}
359

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

    
371
    /* unpack groups */
372
    group_size = exp_strategy + (exp_strategy == EXP_D45);
373
    for(grp=0,i=0; grp<ngrps; grp++) {
374
        expacc = get_bits(gbc, 7);
375
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
376
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
377
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
378
    }
379

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

    
396
/**
397
 * Generate transform coefficients for each coupled channel in the coupling
398
 * range using the coupling coefficients and coupling coordinates.
399
 * reference: Section 7.4.3 Coupling Coordinate Format
400
 */
401
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
402
{
403
    int bin, band, ch;
404

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

    
425
/**
426
 * Grouped mantissas for 3-level 5-level and 11-level quantization
427
 */
428
typedef struct {
429
    int b1_mant[2];
430
    int b2_mant[2];
431
    int b4_mant;
432
    int b1;
433
    int b2;
434
    int b4;
435
} mant_groups;
436

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

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

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

    
524
    for(ch=1; ch<=s->fbw_channels; ch++) {
525
        if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
526
            for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
527
                if(!s->bap[CPL_CH][i])
528
                    s->fixed_coeffs[ch][i] = 0;
529
            }
530
        }
531
    }
532
}
533

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

    
551
/**
552
 * Decode the transform coefficients.
553
 */
554
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
555
{
556
    int ch, end;
557
    int got_cplchan = 0;
558
    mant_groups m;
559

    
560
    m.b1 = m.b2 = m.b4 = 0;
561

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

    
582
    /* zero the dithered coefficients for appropriate channels */
583
    remove_dithering(s);
584
}
585

    
586
/**
587
 * Stereo rematrixing.
588
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
589
 */
590
static void do_rematrixing(AC3DecodeContext *s)
591
{
592
    int bnd, i;
593
    int end, bndend;
594

    
595
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
596

    
597
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
598
        if(s->rematrixing_flags[bnd]) {
599
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
600
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
601
                int tmp0 = s->fixed_coeffs[1][i];
602
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
603
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
604
            }
605
        }
606
    }
607
}
608

    
609
/**
610
 * Inverse MDCT Transform.
611
 * Convert frequency domain coefficients to time-domain audio samples.
612
 * reference: Section 7.9.4 Transformation Equations
613
 */
614
static inline void do_imdct(AC3DecodeContext *s, int channels)
615
{
616
    int ch;
617

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

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

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

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

    
718
    n_subbands = end_subband - start_subband;
719

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

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

    
750
    /* set optional output params */
751
    if (num_bands)
752
        *num_bands = n_bands;
753
    if (band_sizes)
754
        memcpy(band_sizes, bnd_sz, n_bands);
755
}
756

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

    
771
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
772

    
773
    /* block switch flags */
774
    different_transforms = 0;
775
    if (s->block_switch_syntax) {
776
        for (ch = 1; ch <= fbw_channels; ch++) {
777
            s->block_switch[ch] = get_bits1(gbc);
778
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
779
                different_transforms = 1;
780
        }
781
    }
782

    
783
    /* dithering flags */
784
    if (s->dither_flag_syntax) {
785
        for (ch = 1; ch <= fbw_channels; ch++) {
786
            s->dither_flag[ch] = get_bits1(gbc);
787
        }
788
    }
789

    
790
    /* dynamic range */
791
    i = !(s->channel_mode);
792
    do {
793
        if(get_bits1(gbc)) {
794
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
795
                                  s->avctx->drc_scale)+1.0;
796
        } else if(blk == 0) {
797
            s->dynamic_range[i] = 1.0f;
798
        }
799
    } while(i--);
800

    
801
    /* spectral extension strategy */
802
    if (s->eac3 && (!blk || get_bits1(gbc))) {
803
        s->spx_in_use = get_bits1(gbc);
804
        if (s->spx_in_use) {
805
            int dst_start_freq, dst_end_freq, src_start_freq,
806
                start_subband, end_subband;
807

    
808
            /* determine which channels use spx */
809
            if (s->channel_mode == AC3_CHMODE_MONO) {
810
                s->channel_uses_spx[1] = 1;
811
            } else {
812
                for (ch = 1; ch <= fbw_channels; ch++)
813
                    s->channel_uses_spx[ch] = get_bits1(gbc);
814
            }
815

    
816
            /* get the frequency bins of the spx copy region and the spx start
817
               and end subbands */
818
            dst_start_freq = get_bits(gbc, 2);
819
            start_subband  = get_bits(gbc, 3) + 2;
820
            if (start_subband > 7)
821
                start_subband += start_subband - 7;
822
            end_subband    = get_bits(gbc, 3) + 5;
823
            if (end_subband   > 7)
824
                end_subband   += end_subband   - 7;
825
            dst_start_freq = dst_start_freq * 12 + 25;
826
            src_start_freq = start_subband  * 12 + 25;
827
            dst_end_freq   = end_subband    * 12 + 25;
828

    
829
            /* check validity of spx ranges */
830
            if (start_subband >= end_subband) {
831
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
832
                       "range (%d >= %d)\n", start_subband, end_subband);
833
                return -1;
834
            }
835
            if (dst_start_freq >= src_start_freq) {
836
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
837
                       "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
838
                return -1;
839
            }
840

    
841
            s->spx_dst_start_freq = dst_start_freq;
842
            s->spx_src_start_freq = src_start_freq;
843
            s->spx_dst_end_freq   = dst_end_freq;
844

    
845
            decode_band_structure(gbc, blk, s->eac3, 0,
846
                                  start_subband, end_subband,
847
                                  ff_eac3_default_spx_band_struct,
848
                                  &s->num_spx_bands,
849
                                  s->spx_band_sizes);
850
        } else {
851
            for (ch = 1; ch <= fbw_channels; ch++) {
852
                s->channel_uses_spx[ch] = 0;
853
                s->first_spx_coords[ch] = 1;
854
            }
855
        }
856
    }
857

    
858
    /* spectral extension coordinates */
859
    if (s->spx_in_use) {
860
        for (ch = 1; ch <= fbw_channels; ch++) {
861
            if (s->channel_uses_spx[ch]) {
862
                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
863
                    float spx_blend;
864
                    int bin, master_spx_coord;
865

    
866
                    s->first_spx_coords[ch] = 0;
867
                    spx_blend = get_bits(gbc, 5) * (1.0f/32);
868
                    master_spx_coord = get_bits(gbc, 2) * 3;
869

    
870
                    bin = s->spx_src_start_freq;
871
                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
872
                        int bandsize;
873
                        int spx_coord_exp, spx_coord_mant;
874
                        float nratio, sblend, nblend, spx_coord;
875

    
876
                        /* calculate blending factors */
877
                        bandsize = s->spx_band_sizes[bnd];
878
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
879
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
880
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
881
                        sblend = sqrtf(1.0f - nratio);
882
                        bin += bandsize;
883

    
884
                        /* decode spx coordinates */
885
                        spx_coord_exp  = get_bits(gbc, 4);
886
                        spx_coord_mant = get_bits(gbc, 2);
887
                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
888
                        else                     spx_coord_mant += 4;
889
                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
890
                        spx_coord = spx_coord_mant * (1.0f/(1<<23));
891

    
892
                        /* multiply noise and signal blending factors by spx coordinate */
893
                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
894
                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
895
                    }
896
                }
897
            } else {
898
                s->first_spx_coords[ch] = 1;
899
            }
900
        }
901
    }
902

    
903
    /* coupling strategy */
904
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
905
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
906
        if (!s->eac3)
907
            s->cpl_in_use[blk] = get_bits1(gbc);
908
        if (s->cpl_in_use[blk]) {
909
            /* coupling in use */
910
            int cpl_start_subband, cpl_end_subband;
911

    
912
            if (channel_mode < AC3_CHMODE_STEREO) {
913
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
914
                return -1;
915
            }
916

    
917
            /* check for enhanced coupling */
918
            if (s->eac3 && get_bits1(gbc)) {
919
                /* TODO: parse enhanced coupling strategy info */
920
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
921
                return -1;
922
            }
923

    
924
            /* determine which channels are coupled */
925
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
926
                s->channel_in_cpl[1] = 1;
927
                s->channel_in_cpl[2] = 1;
928
            } else {
929
                for (ch = 1; ch <= fbw_channels; ch++)
930
                    s->channel_in_cpl[ch] = get_bits1(gbc);
931
            }
932

    
933
            /* phase flags in use */
934
            if (channel_mode == AC3_CHMODE_STEREO)
935
                s->phase_flags_in_use = get_bits1(gbc);
936

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

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

    
972
    /* coupling coordinates */
973
    if (cpl_in_use) {
974
        int cpl_coords_exist = 0;
975

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

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

    
1026
    /* exponent strategies for each channel */
1027
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1028
        if (!s->eac3)
1029
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1030
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
1031
            bit_alloc_stages[ch] = 3;
1032
    }
1033

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

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

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

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

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

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

    
1139
    /* E-AC-3 to AC-3 converter SNR offset */
1140
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1141
        skip_bits(gbc, 10); // skip converter snr offset
1142
    }
1143

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

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

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

    
1227
    /* unused dummy data */
1228
    if (s->skip_syntax && get_bits1(gbc)) {
1229
        int skipl = get_bits(gbc, 9);
1230
        while(skipl--)
1231
            skip_bits(gbc, 8);
1232
    }
1233

    
1234
    /* unpack the transform coefficients
1235
       this also uncouples channels if coupling is in use. */
1236
    decode_transform_coeffs(s, blk);
1237

    
1238
    /* TODO: generate enhanced coupling coordinates and uncouple */
1239

    
1240
    /* recover coefficients if rematrixing is in use */
1241
    if(s->channel_mode == AC3_CHMODE_STEREO)
1242
        do_rematrixing(s);
1243

    
1244
    /* apply scaling to coefficients (headroom, dynrng) */
1245
    for(ch=1; ch<=s->channels; ch++) {
1246
        float gain = s->mul_bias / 4194304.0f;
1247
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1248
            gain *= s->dynamic_range[2-ch];
1249
        } else {
1250
            gain *= s->dynamic_range[0];
1251
        }
1252
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1253
    }
1254

    
1255
    /* apply spectral extension to high frequency bins */
1256
    if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1257
        ff_eac3_apply_spectral_extension(s);
1258
    }
1259

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

    
1274
        do_imdct(s, s->channels);
1275

    
1276
        if(downmix_output) {
1277
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1278
        }
1279
    } else {
1280
        if(downmix_output) {
1281
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1282
        }
1283

    
1284
        if(downmix_output && !s->downmixed) {
1285
            s->downmixed = 1;
1286
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1287
        }
1288

    
1289
        do_imdct(s, s->out_channels);
1290
    }
1291

    
1292
    return 0;
1293
}
1294

    
1295
/**
1296
 * Decode a single AC-3 frame.
1297
 */
1298
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1299
                            AVPacket *avpkt)
1300
{
1301
    const uint8_t *buf = avpkt->data;
1302
    int buf_size = avpkt->size;
1303
    AC3DecodeContext *s = avctx->priv_data;
1304
    int16_t *out_samples = (int16_t *)data;
1305
    int blk, ch, err;
1306
    const uint8_t *channel_map;
1307
    const float *output[AC3_MAX_CHANNELS];
1308
    // if it seems to be byte-swapped AC-3 (aka DNET)
1309
    int is_swapped = buf_size >= 2 && AV_RB16(buf) == 0x770B;
1310

    
1311
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1312
    if (is_swapped || avctx->error_recognition >= FF_ER_CAREFUL) {
1313
        /* allocate context input buffer */
1314
        if (!s->input_buffer)
1315
            s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
1316
        if (!s->input_buffer)
1317
            return AVERROR(ENOMEM);
1318

    
1319
        /* copy input buffer to decoder context to avoid reading past the end
1320
           of the buffer, which can be caused by a damaged input stream. */
1321
        if (is_swapped) {
1322
            int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1323
            s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1324
        } else
1325
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1326
        buf = s->input_buffer;
1327
    }
1328
    init_get_bits(&s->gbc, buf, buf_size * 8);
1329

    
1330
    /* parse the syncinfo */
1331
    *data_size = 0;
1332
    err = parse_frame_header(s);
1333

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

    
1376
    /* if frame is ok, set audio parameters */
1377
    if (!err) {
1378
        avctx->sample_rate = s->sample_rate;
1379
        avctx->bit_rate = s->bit_rate;
1380

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

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

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

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

    
1431
    av_freep(&s->input_buffer);
1432

    
1433
    return 0;
1434
}
1435

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

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