Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 0e09997f

History | View | Annotate | Download (52.5 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
/** Large enough for maximum possible frame size when the specification limit is ignored */
41
#define AC3_FRAME_BUFFER_SIZE 32768
42

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

    
49

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

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

    
66
/** dynamic range table. converts codes to scale factors. */
67
static float dynamic_range_tab[256];
68

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

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

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

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

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

    
120
/*
121
 * Initialize tables at runtime.
122
 */
123
static av_cold void ac3_tables_init(void)
124
{
125
    int i;
126

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

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

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

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

    
172

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

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

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

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

    
207
    /* allocate context input buffer */
208
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
209
        if (!s->input_buffer)
210
            return AVERROR(ENOMEM);
211

    
212
    /* ffdshow custom code */
213
#if CONFIG_AUDIO_FLOAT
214
    avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
215
#else
216
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
217
#endif
218
    return 0;
219
}
220

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

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

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

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

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

    
260
    return 0;
261
}
262

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
568
    m.b1 = m.b2 = m.b4 = 0;
569

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

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

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

    
603
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
604

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

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

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

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

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

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

    
726
    n_subbands = end_subband - start_subband;
727

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

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

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

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

    
779
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
780

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

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

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

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

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

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

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

    
849
            s->spx_dst_start_freq = dst_start_freq;
850
            s->spx_src_start_freq = src_start_freq;
851
            s->spx_dst_end_freq   = dst_end_freq;
852

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1246
    /* TODO: generate enhanced coupling coordinates and uncouple */
1247

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

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

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

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

    
1282
        do_imdct(s, s->channels);
1283

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

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

    
1297
        do_imdct(s, s->out_channels);
1298
    }
1299

    
1300
    return 0;
1301
}
1302

    
1303
/**
1304
 * Decode a single AC-3 frame.
1305
 */
1306
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1307
                            AVPacket *avpkt)
1308
{
1309
    const uint8_t *buf = avpkt->data;
1310
    int buf_size = avpkt->size;
1311
    AC3DecodeContext *s = avctx->priv_data;
1312
    /* ffdshow custom code */
1313
#if CONFIG_AUDIO_FLOAT
1314
    float *out_samples = (float *)data;
1315
#else
1316
    int16_t *out_samples = (int16_t *)data;
1317
#endif
1318
    int blk, ch, err;
1319
    const uint8_t *channel_map;
1320
    const float *output[AC3_MAX_CHANNELS];
1321

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

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

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

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

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

    
1399
        /* set downmixing coefficients if needed */
1400
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1401
                s->fbw_channels == s->out_channels)) {
1402
            set_downmix_coeffs(s);
1403
        }
1404
    } else if (!s->out_channels) {
1405
        s->out_channels = avctx->channels;
1406
        if(s->out_channels < s->channels)
1407
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1408
    }
1409
    /* set audio service type based on bitstream mode for AC-3 */
1410
    avctx->audio_service_type = s->bitstream_mode;
1411
    if (s->bitstream_mode == 0x7 && s->channels > 1)
1412
        avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1413

    
1414
    /* decode the audio blocks */
1415
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1416
    for (ch = 0; ch < s->out_channels; ch++)
1417
        output[ch] = s->output[channel_map[ch]];
1418
    for (blk = 0; blk < s->num_blocks; blk++) {
1419
        if (!err && decode_audio_block(s, blk)) {
1420
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1421
            err = 1;
1422
        }
1423
        /* ffdshow custom code */
1424
#if CONFIG_AUDIO_FLOAT
1425
        float_interleave_noscale(out_samples, output, 256, s->out_channels);
1426
#else
1427
        s->fmt_conv.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1428
#endif
1429
        out_samples += 256 * s->out_channels;
1430
    }
1431
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (out_samples[0]); /* ffdshow custom code */
1432
    return FFMIN(buf_size, s->frame_size);
1433
}
1434

    
1435
/**
1436
 * Uninitialize the AC-3 decoder.
1437
 */
1438
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1439
{
1440
    AC3DecodeContext *s = avctx->priv_data;
1441
    ff_mdct_end(&s->imdct_512);
1442
    ff_mdct_end(&s->imdct_256);
1443

    
1444
    av_freep(&s->input_buffer);
1445

    
1446
    return 0;
1447
}
1448

    
1449
AVCodec ff_ac3_decoder = {
1450
    .name = "ac3",
1451
    .type = AVMEDIA_TYPE_AUDIO,
1452
    .id = CODEC_ID_AC3,
1453
    .priv_data_size = sizeof (AC3DecodeContext),
1454
    .init = ac3_decode_init,
1455
    .close = ac3_decode_end,
1456
    .decode = ac3_decode_frame,
1457
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1458
};
1459

    
1460
#if CONFIG_EAC3_DECODER
1461
AVCodec ff_eac3_decoder = {
1462
    .name = "eac3",
1463
    .type = AVMEDIA_TYPE_AUDIO,
1464
    .id = CODEC_ID_EAC3,
1465
    .priv_data_size = sizeof (AC3DecodeContext),
1466
    .init = ac3_decode_init,
1467
    .close = ac3_decode_end,
1468
    .decode = ac3_decode_frame,
1469
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1470
};
1471
#endif