Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 6e075dca

History | View | Annotate | Download (52.1 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
#include "kbdwin.h"
39

    
40
/**
41
 * table for ungrouping 3 values in 7 bits.
42
 * used for exponents and bap=2 mantissas
43
 */
44
static uint8_t ungroup_3_in_7_bits_tab[128][3];
45

    
46

    
47
/** tables for ungrouping mantissas */
48
static int b1_mantissas[32][3];
49
static int b2_mantissas[128][3];
50
static int b3_mantissas[8];
51
static int b4_mantissas[128][2];
52
static int b5_mantissas[16];
53

    
54
/**
55
 * Quantization table: levels for symmetric. bits for asymmetric.
56
 * reference: Table 7.18 Mapping of bap to Quantizer
57
 */
58
static const uint8_t quantization_tab[16] = {
59
    0, 3, 5, 7, 11, 15,
60
    5, 6, 7, 8, 9, 10, 11, 12, 14, 16
61
};
62

    
63
/** dynamic range table. converts codes to scale factors. */
64
static float dynamic_range_tab[256];
65

    
66
/** Adjustments in dB gain */
67
static const float gain_levels[9] = {
68
    LEVEL_PLUS_3DB,
69
    LEVEL_PLUS_1POINT5DB,
70
    LEVEL_ONE,
71
    LEVEL_MINUS_1POINT5DB,
72
    LEVEL_MINUS_3DB,
73
    LEVEL_MINUS_4POINT5DB,
74
    LEVEL_MINUS_6DB,
75
    LEVEL_ZERO,
76
    LEVEL_MINUS_9DB
77
};
78

    
79
/**
80
 * Table for center mix levels
81
 * reference: Section 5.4.2.4 cmixlev
82
 */
83
static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
84

    
85
/**
86
 * Table for surround mix levels
87
 * reference: Section 5.4.2.5 surmixlev
88
 */
89
static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
90

    
91
/**
92
 * Table for default stereo downmixing coefficients
93
 * reference: Section 7.8.2 Downmixing Into Two Channels
94
 */
95
static const uint8_t ac3_default_coeffs[8][5][2] = {
96
    { { 2, 7 }, { 7, 2 },                               },
97
    { { 4, 4 },                                         },
98
    { { 2, 7 }, { 7, 2 },                               },
99
    { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
100
    { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
101
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
102
    { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
103
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
104
};
105

    
106
/**
107
 * Symmetrical Dequantization
108
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
109
 *            Tables 7.19 to 7.23
110
 */
111
static inline int
112
symmetric_dequant(int code, int levels)
113
{
114
    return ((code - (levels >> 1)) << 24) / levels;
115
}
116

    
117
/*
118
 * Initialize tables at runtime.
119
 */
120
static av_cold void ac3_tables_init(void)
121
{
122
    int i;
123

    
124
    /* generate table for ungrouping 3 values in 7 bits
125
       reference: Section 7.1.3 Exponent Decoding */
126
    for(i=0; i<128; i++) {
127
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
128
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
129
        ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
130
    }
131

    
132
    /* generate grouped mantissa tables
133
       reference: Section 7.3.5 Ungrouping of Mantissas */
134
    for(i=0; i<32; i++) {
135
        /* bap=1 mantissas */
136
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
137
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
138
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
139
    }
140
    for(i=0; i<128; i++) {
141
        /* bap=2 mantissas */
142
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
143
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
144
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
145

    
146
        /* bap=4 mantissas */
147
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
148
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
149
    }
150
    /* generate ungrouped mantissa tables
151
       reference: Tables 7.21 and 7.23 */
152
    for(i=0; i<7; i++) {
153
        /* bap=3 mantissas */
154
        b3_mantissas[i] = symmetric_dequant(i, 7);
155
    }
156
    for(i=0; i<15; i++) {
157
        /* bap=5 mantissas */
158
        b5_mantissas[i] = symmetric_dequant(i, 15);
159
    }
160

    
161
    /* generate dynamic range table
162
       reference: Section 7.7.1 Dynamic Range Control */
163
    for(i=0; i<256; i++) {
164
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
165
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
166
    }
167
}
168

    
169

    
170
/**
171
 * AVCodec initialization
172
 */
173
static av_cold int ac3_decode_init(AVCodecContext *avctx)
174
{
175
    AC3DecodeContext *s = avctx->priv_data;
176
    s->avctx = avctx;
177

    
178
    ff_ac3_common_init();
179
    ac3_tables_init();
180
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
181
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
182
    ff_kbd_window_init(s->window, 5.0, 256);
183
    dsputil_init(&s->dsp, avctx);
184
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
185
    ff_fmt_convert_init(&s->fmt_conv, avctx);
186
    av_lfg_init(&s->dith_state, 0);
187

    
188
    /* ffdshow custom code */
189
#if CONFIG_AUDIO_FLOAT
190
    s->mul_bias = 1.0f;
191
#else
192
    /* set scale value for float to int16 conversion */
193
    s->mul_bias = 32767.0f;
194
#endif
195

    
196
    /* allow downmixing to stereo or mono */
197
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
198
            avctx->request_channels < avctx->channels &&
199
            avctx->request_channels <= 2) {
200
        avctx->channels = avctx->request_channels;
201
    }
202
    s->downmixed = 1;
203

    
204
    /* ffdshow custom code */
205
#if CONFIG_AUDIO_FLOAT
206
    avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
207
#else
208
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
209
#endif
210
    return 0;
211
}
212

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

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

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

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

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

    
252
    return 0;
253
}
254

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

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

    
267
    /* get decoding parameters from header info */
268
    s->bit_alloc_params.sr_code     = hdr.sr_code;
269
    s->bitstream_mode               = hdr.bitstream_mode;
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
            s->imdct_256.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
            s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch-1], x);
629
        } else {
630
            s->imdct_512.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
            s->ac3dsp.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
    /* ffdshow custom code */
1305
#if CONFIG_AUDIO_FLOAT
1306
    float *out_samples = (float *)data;
1307
#else
1308
    int16_t *out_samples = (int16_t *)data;
1309
#endif
1310
    int blk, ch, err;
1311
    const uint8_t *channel_map;
1312
    const float *output[AC3_MAX_CHANNELS];
1313

    
1314
    /* copy input buffer to decoder context to avoid reading past the end
1315
       of the buffer, which can be caused by a damaged input stream. */
1316
    if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1317
        // seems to be byte-swapped AC-3
1318
        int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1319
        s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1320
    } else
1321
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1322
    buf = s->input_buffer;
1323
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1324
    init_get_bits(&s->gbc, buf, buf_size * 8);
1325

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

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

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

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

    
1391
        /* set downmixing coefficients if needed */
1392
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1393
                s->fbw_channels == s->out_channels)) {
1394
            set_downmix_coeffs(s);
1395
        }
1396
    } else if (!s->out_channels) {
1397
        s->out_channels = avctx->channels;
1398
        if(s->out_channels < s->channels)
1399
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1400
    }
1401
    /* set audio service type based on bitstream mode for AC-3 */
1402
    avctx->audio_service_type = s->bitstream_mode;
1403
    if (s->bitstream_mode == 0x7 && s->channels > 1)
1404
        avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
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
        /* ffdshow custom code */
1416
#if CONFIG_AUDIO_FLOAT
1417
        float_interleave_noscale(out_samples, output, 256, s->out_channels);
1418
#else
1419
        s->fmt_conv.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1420
#endif
1421
        out_samples += 256 * s->out_channels;
1422
    }
1423
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (out_samples[0]); /* ffdshow custom code */
1424
    return FFMIN(buf_size, s->frame_size);
1425
}
1426

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

    
1436
    return 0;
1437
}
1438

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

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