Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ a45fbda9

History | View | Annotate | Download (52 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 Libav.
11
 *
12
 * Libav 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
 * Libav 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 Libav; 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
#define LEVEL_PLUS_3DB          1.4142135623730950
71
#define LEVEL_PLUS_1POINT5DB    1.1892071150027209
72
#define LEVEL_MINUS_1POINT5DB   0.8408964152537145
73
#define LEVEL_MINUS_3DB         0.7071067811865476
74
#define LEVEL_MINUS_4POINT5DB   0.5946035575013605
75
#define LEVEL_MINUS_6DB         0.5000000000000000
76
#define LEVEL_MINUS_9DB         0.3535533905932738
77
#define LEVEL_ZERO              0.0000000000000000
78
#define LEVEL_ONE               1.0000000000000000
79

    
80
static const float gain_levels[9] = {
81
    LEVEL_PLUS_3DB,
82
    LEVEL_PLUS_1POINT5DB,
83
    LEVEL_ONE,
84
    LEVEL_MINUS_1POINT5DB,
85
    LEVEL_MINUS_3DB,
86
    LEVEL_MINUS_4POINT5DB,
87
    LEVEL_MINUS_6DB,
88
    LEVEL_ZERO,
89
    LEVEL_MINUS_9DB
90
};
91

    
92
/**
93
 * Table for center mix levels
94
 * reference: Section 5.4.2.4 cmixlev
95
 */
96
static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
97

    
98
/**
99
 * Table for surround mix levels
100
 * reference: Section 5.4.2.5 surmixlev
101
 */
102
static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
103

    
104
/**
105
 * Table for default stereo downmixing coefficients
106
 * reference: Section 7.8.2 Downmixing Into Two Channels
107
 */
108
static const uint8_t ac3_default_coeffs[8][5][2] = {
109
    { { 2, 7 }, { 7, 2 },                               },
110
    { { 4, 4 },                                         },
111
    { { 2, 7 }, { 7, 2 },                               },
112
    { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
113
    { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
114
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
115
    { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
116
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
117
};
118

    
119
/**
120
 * Symmetrical Dequantization
121
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
122
 *            Tables 7.19 to 7.23
123
 */
124
static inline int
125
symmetric_dequant(int code, int levels)
126
{
127
    return ((code - (levels >> 1)) << 24) / levels;
128
}
129

    
130
/*
131
 * Initialize tables at runtime.
132
 */
133
static av_cold void ac3_tables_init(void)
134
{
135
    int i;
136

    
137
    /* generate table for ungrouping 3 values in 7 bits
138
       reference: Section 7.1.3 Exponent Decoding */
139
    for(i=0; i<128; i++) {
140
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
141
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
142
        ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
143
    }
144

    
145
    /* generate grouped mantissa tables
146
       reference: Section 7.3.5 Ungrouping of Mantissas */
147
    for(i=0; i<32; i++) {
148
        /* bap=1 mantissas */
149
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
150
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
151
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
152
    }
153
    for(i=0; i<128; i++) {
154
        /* bap=2 mantissas */
155
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
156
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
157
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
158

    
159
        /* bap=4 mantissas */
160
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
161
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
162
    }
163
    /* generate ungrouped mantissa tables
164
       reference: Tables 7.21 and 7.23 */
165
    for(i=0; i<7; i++) {
166
        /* bap=3 mantissas */
167
        b3_mantissas[i] = symmetric_dequant(i, 7);
168
    }
169
    for(i=0; i<15; i++) {
170
        /* bap=5 mantissas */
171
        b5_mantissas[i] = symmetric_dequant(i, 15);
172
    }
173

    
174
    /* generate dynamic range table
175
       reference: Section 7.7.1 Dynamic Range Control */
176
    for(i=0; i<256; i++) {
177
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
178
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
179
    }
180
}
181

    
182

    
183
/**
184
 * AVCodec initialization
185
 */
186
static av_cold int ac3_decode_init(AVCodecContext *avctx)
187
{
188
    AC3DecodeContext *s = avctx->priv_data;
189
    s->avctx = avctx;
190

    
191
    ff_ac3_common_init();
192
    ac3_tables_init();
193
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
194
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
195
    ff_kbd_window_init(s->window, 5.0, 256);
196
    dsputil_init(&s->dsp, avctx);
197
    ff_fmt_convert_init(&s->fmt_conv, avctx);
198
    av_lfg_init(&s->dith_state, 0);
199

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

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

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

    
218
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
219
    return 0;
220
}
221

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

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

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

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

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

    
261
    return 0;
262
}
263

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

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

    
276
    /* get decoding parameters from header info */
277
    s->bit_alloc_params.sr_code     = hdr.sr_code;
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
            ff_ac3_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
    int16_t *out_samples = (int16_t *)data;
1313
    int blk, ch, err;
1314
    const uint8_t *channel_map;
1315
    const float *output[AC3_MAX_CHANNELS];
1316

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

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

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

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

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

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

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

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

    
1428
    av_freep(&s->input_buffer);
1429

    
1430
    return 0;
1431
}
1432

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

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