Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ bfeca7be

History | View | Annotate | Download (47.8 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
 * Portions of this code are derived from liba52
11
 * http://liba52.sourceforge.net
12
 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
13
 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
14
 *
15
 * This file is part of FFmpeg.
16
 *
17
 * FFmpeg is free software; you can redistribute it and/or
18
 * modify it under the terms of the GNU General Public
19
 * License as published by the Free Software Foundation; either
20
 * version 2 of the License, or (at your option) any later version.
21
 *
22
 * FFmpeg is distributed in the hope that it will be useful,
23
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
 * General Public License for more details.
26
 *
27
 * You should have received a copy of the GNU General Public
28
 * License along with FFmpeg; if not, write to the Free Software
29
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30
 */
31

    
32
#include <stdio.h>
33
#include <stddef.h>
34
#include <math.h>
35
#include <string.h>
36

    
37
#include "libavutil/crc.h"
38
#include "internal.h"
39
#include "aac_ac3_parser.h"
40
#include "ac3_parser.h"
41
#include "ac3dec.h"
42
#include "ac3dec_data.h"
43

    
44
/** Large enough for maximum possible frame size when the specification limit is ignored */
45
#define AC3_FRAME_BUFFER_SIZE 32768
46

    
47
/**
48
 * table for ungrouping 3 values in 7 bits.
49
 * used for exponents and bap=2 mantissas
50
 */
51
static uint8_t ungroup_3_in_7_bits_tab[128][3];
52

    
53

    
54
/** tables for ungrouping mantissas */
55
static int b1_mantissas[32][3];
56
static int b2_mantissas[128][3];
57
static int b3_mantissas[8];
58
static int b4_mantissas[128][2];
59
static int b5_mantissas[16];
60

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

    
70
/** dynamic range table. converts codes to scale factors. */
71
static float dynamic_range_tab[256];
72

    
73
/** Adjustments in dB gain */
74
#define LEVEL_PLUS_3DB          1.4142135623730950
75
#define LEVEL_PLUS_1POINT5DB    1.1892071150027209
76
#define LEVEL_MINUS_1POINT5DB   0.8408964152537145
77
#define LEVEL_MINUS_3DB         0.7071067811865476
78
#define LEVEL_MINUS_4POINT5DB   0.5946035575013605
79
#define LEVEL_MINUS_6DB         0.5000000000000000
80
#define LEVEL_MINUS_9DB         0.3535533905932738
81
#define LEVEL_ZERO              0.0000000000000000
82
#define LEVEL_ONE               1.0000000000000000
83

    
84
static const float gain_levels[9] = {
85
    LEVEL_PLUS_3DB,
86
    LEVEL_PLUS_1POINT5DB,
87
    LEVEL_ONE,
88
    LEVEL_MINUS_1POINT5DB,
89
    LEVEL_MINUS_3DB,
90
    LEVEL_MINUS_4POINT5DB,
91
    LEVEL_MINUS_6DB,
92
    LEVEL_ZERO,
93
    LEVEL_MINUS_9DB
94
};
95

    
96
/**
97
 * Table for center mix levels
98
 * reference: Section 5.4.2.4 cmixlev
99
 */
100
static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
101

    
102
/**
103
 * Table for surround mix levels
104
 * reference: Section 5.4.2.5 surmixlev
105
 */
106
static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
107

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

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

    
134
/*
135
 * Initialize tables at runtime.
136
 */
137
static av_cold void ac3_tables_init(void)
138
{
139
    int i;
140

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

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

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

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

    
186

    
187
/**
188
 * AVCodec initialization
189
 */
190
static av_cold int ac3_decode_init(AVCodecContext *avctx)
191
{
192
    AC3DecodeContext *s = avctx->priv_data;
193
    s->avctx = avctx;
194

    
195
    ac3_common_init();
196
    ac3_tables_init();
197
    ff_mdct_init(&s->imdct_256, 8, 1);
198
    ff_mdct_init(&s->imdct_512, 9, 1);
199
    ff_kbd_window_init(s->window, 5.0, 256);
200
    dsputil_init(&s->dsp, avctx);
201
    av_lfg_init(&s->dith_state, 0);
202

    
203
    /* set bias values for float to int16 conversion */
204
    if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
205
        s->add_bias = 385.0f;
206
        s->mul_bias = 1.0f;
207
    } else {
208
        s->add_bias = 0.0f;
209
        s->mul_bias = 32767.0f;
210
    }
211

    
212
    /* allow downmixing to stereo or mono */
213
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
214
            avctx->request_channels < avctx->channels &&
215
            avctx->request_channels <= 2) {
216
        avctx->channels = avctx->request_channels;
217
    }
218
    s->downmixed = 1;
219

    
220
    /* allocate context input buffer */
221
    if (avctx->error_recognition >= FF_ER_CAREFUL) {
222
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
223
        if (!s->input_buffer)
224
            return AVERROR_NOMEM;
225
    }
226

    
227
    avctx->sample_fmt = SAMPLE_FMT_S16;
228
    return 0;
229
}
230

    
231
/**
232
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
233
 * GetBitContext within AC3DecodeContext must point to
234
 * the start of the synchronized AC-3 bitstream.
235
 */
236
static int ac3_parse_header(AC3DecodeContext *s)
237
{
238
    GetBitContext *gbc = &s->gbc;
239
    int i;
240

    
241
    /* read the rest of the bsi. read twice for dual mono mode. */
242
    i = !(s->channel_mode);
243
    do {
244
        skip_bits(gbc, 5); // skip dialog normalization
245
        if (get_bits1(gbc))
246
            skip_bits(gbc, 8); //skip compression
247
        if (get_bits1(gbc))
248
            skip_bits(gbc, 8); //skip language code
249
        if (get_bits1(gbc))
250
            skip_bits(gbc, 7); //skip audio production information
251
    } while (i--);
252

    
253
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
254

    
255
    /* skip the timecodes (or extra bitstream information for Alternate Syntax)
256
       TODO: read & use the xbsi1 downmix levels */
257
    if (get_bits1(gbc))
258
        skip_bits(gbc, 14); //skip timecode1 / xbsi1
259
    if (get_bits1(gbc))
260
        skip_bits(gbc, 14); //skip timecode2 / xbsi2
261

    
262
    /* skip additional bitstream info */
263
    if (get_bits1(gbc)) {
264
        i = get_bits(gbc, 6);
265
        do {
266
            skip_bits(gbc, 8);
267
        } while(i--);
268
    }
269

    
270
    return 0;
271
}
272

    
273
/**
274
 * Common function to parse AC-3 or E-AC-3 frame header
275
 */
276
static int parse_frame_header(AC3DecodeContext *s)
277
{
278
    AC3HeaderInfo hdr;
279
    int err;
280

    
281
    err = ff_ac3_parse_header(&s->gbc, &hdr);
282
    if(err)
283
        return err;
284

    
285
    /* get decoding parameters from header info */
286
    s->bit_alloc_params.sr_code     = hdr.sr_code;
287
    s->channel_mode                 = hdr.channel_mode;
288
    s->channel_layout               = hdr.channel_layout;
289
    s->lfe_on                       = hdr.lfe_on;
290
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
291
    s->sample_rate                  = hdr.sample_rate;
292
    s->bit_rate                     = hdr.bit_rate;
293
    s->channels                     = hdr.channels;
294
    s->fbw_channels                 = s->channels - s->lfe_on;
295
    s->lfe_ch                       = s->fbw_channels + 1;
296
    s->frame_size                   = hdr.frame_size;
297
    s->center_mix_level             = hdr.center_mix_level;
298
    s->surround_mix_level           = hdr.surround_mix_level;
299
    s->num_blocks                   = hdr.num_blocks;
300
    s->frame_type                   = hdr.frame_type;
301
    s->substreamid                  = hdr.substreamid;
302

    
303
    if(s->lfe_on) {
304
        s->start_freq[s->lfe_ch] = 0;
305
        s->end_freq[s->lfe_ch] = 7;
306
        s->num_exp_groups[s->lfe_ch] = 2;
307
        s->channel_in_cpl[s->lfe_ch] = 0;
308
    }
309

    
310
    if (hdr.bitstream_id <= 10) {
311
        s->eac3                  = 0;
312
        s->snr_offset_strategy   = 2;
313
        s->block_switch_syntax   = 1;
314
        s->dither_flag_syntax    = 1;
315
        s->bit_allocation_syntax = 1;
316
        s->fast_gain_syntax      = 0;
317
        s->first_cpl_leak        = 0;
318
        s->dba_syntax            = 1;
319
        s->skip_syntax           = 1;
320
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
321
        return ac3_parse_header(s);
322
    } else {
323
        s->eac3 = 1;
324
        return ff_eac3_parse_header(s);
325
    }
326
}
327

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

    
339
    for(i=0; i<s->fbw_channels; i++) {
340
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
341
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
342
    }
343
    if(s->channel_mode > 1 && s->channel_mode & 1) {
344
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
345
    }
346
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
347
        int nf = s->channel_mode - 2;
348
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
349
    }
350
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
351
        int nf = s->channel_mode - 4;
352
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
353
    }
354

    
355
    /* renormalize */
356
    norm0 = norm1 = 0.0;
357
    for(i=0; i<s->fbw_channels; i++) {
358
        norm0 += s->downmix_coeffs[i][0];
359
        norm1 += s->downmix_coeffs[i][1];
360
    }
361
    norm0 = 1.0f / norm0;
362
    norm1 = 1.0f / norm1;
363
    for(i=0; i<s->fbw_channels; i++) {
364
        s->downmix_coeffs[i][0] *= norm0;
365
        s->downmix_coeffs[i][1] *= norm1;
366
    }
367

    
368
    if(s->output_mode == AC3_CHMODE_MONO) {
369
        for(i=0; i<s->fbw_channels; i++)
370
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
371
    }
372
}
373

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

    
385
    /* unpack groups */
386
    group_size = exp_strategy + (exp_strategy == EXP_D45);
387
    for(grp=0,i=0; grp<ngrps; grp++) {
388
        expacc = get_bits(gbc, 7);
389
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
390
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
391
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
392
    }
393

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

    
410
/**
411
 * Generate transform coefficients for each coupled channel in the coupling
412
 * range using the coupling coefficients and coupling coordinates.
413
 * reference: Section 7.4.3 Coupling Coordinate Format
414
 */
415
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
416
{
417
    int i, j, ch, bnd, subbnd;
418

    
419
    subbnd = -1;
420
    i = s->start_freq[CPL_CH];
421
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
422
        do {
423
            subbnd++;
424
            for(j=0; j<12; j++) {
425
                for(ch=1; ch<=s->fbw_channels; ch++) {
426
                    if(s->channel_in_cpl[ch]) {
427
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
428
                        if (ch == 2 && s->phase_flags[bnd])
429
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
430
                    }
431
                }
432
                i++;
433
            }
434
        } while(s->cpl_band_struct[subbnd]);
435
    }
436
}
437

    
438
/**
439
 * Grouped mantissas for 3-level 5-level and 11-level quantization
440
 */
441
typedef struct {
442
    int b1_mant[3];
443
    int b2_mant[3];
444
    int b4_mant[2];
445
    int b1ptr;
446
    int b2ptr;
447
    int b4ptr;
448
} mant_groups;
449

    
450
/**
451
 * Decode the transform coefficients for a particular channel
452
 * reference: Section 7.3 Quantization and Decoding of Mantissas
453
 */
454
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
455
{
456
    GetBitContext *gbc = &s->gbc;
457
    int i, gcode, tbap, start, end;
458
    uint8_t *exps;
459
    uint8_t *bap;
460
    int *coeffs;
461

    
462
    exps = s->dexps[ch_index];
463
    bap = s->bap[ch_index];
464
    coeffs = s->fixed_coeffs[ch_index];
465
    start = s->start_freq[ch_index];
466
    end = s->end_freq[ch_index];
467

    
468
    for (i = start; i < end; i++) {
469
        tbap = bap[i];
470
        switch (tbap) {
471
            case 0:
472
                coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
473
                break;
474

    
475
            case 1:
476
                if(m->b1ptr > 2) {
477
                    gcode = get_bits(gbc, 5);
478
                    m->b1_mant[0] = b1_mantissas[gcode][0];
479
                    m->b1_mant[1] = b1_mantissas[gcode][1];
480
                    m->b1_mant[2] = b1_mantissas[gcode][2];
481
                    m->b1ptr = 0;
482
                }
483
                coeffs[i] = m->b1_mant[m->b1ptr++];
484
                break;
485

    
486
            case 2:
487
                if(m->b2ptr > 2) {
488
                    gcode = get_bits(gbc, 7);
489
                    m->b2_mant[0] = b2_mantissas[gcode][0];
490
                    m->b2_mant[1] = b2_mantissas[gcode][1];
491
                    m->b2_mant[2] = b2_mantissas[gcode][2];
492
                    m->b2ptr = 0;
493
                }
494
                coeffs[i] = m->b2_mant[m->b2ptr++];
495
                break;
496

    
497
            case 3:
498
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
499
                break;
500

    
501
            case 4:
502
                if(m->b4ptr > 1) {
503
                    gcode = get_bits(gbc, 7);
504
                    m->b4_mant[0] = b4_mantissas[gcode][0];
505
                    m->b4_mant[1] = b4_mantissas[gcode][1];
506
                    m->b4ptr = 0;
507
                }
508
                coeffs[i] = m->b4_mant[m->b4ptr++];
509
                break;
510

    
511
            case 5:
512
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
513
                break;
514

    
515
            default: {
516
                /* asymmetric dequantization */
517
                int qlevel = quantization_tab[tbap];
518
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
519
                break;
520
            }
521
        }
522
        coeffs[i] >>= exps[i];
523
    }
524
}
525

    
526
/**
527
 * Remove random dithering from coefficients with zero-bit mantissas
528
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
529
 */
530
static void remove_dithering(AC3DecodeContext *s) {
531
    int ch, i;
532
    int end=0;
533
    int *coeffs;
534
    uint8_t *bap;
535

    
536
    for(ch=1; ch<=s->fbw_channels; ch++) {
537
        if(!s->dither_flag[ch]) {
538
            coeffs = s->fixed_coeffs[ch];
539
            bap = s->bap[ch];
540
            if(s->channel_in_cpl[ch])
541
                end = s->start_freq[CPL_CH];
542
            else
543
                end = s->end_freq[ch];
544
            for(i=0; i<end; i++) {
545
                if(!bap[i])
546
                    coeffs[i] = 0;
547
            }
548
            if(s->channel_in_cpl[ch]) {
549
                bap = s->bap[CPL_CH];
550
                for(; i<s->end_freq[CPL_CH]; i++) {
551
                    if(!bap[i])
552
                        coeffs[i] = 0;
553
                }
554
            }
555
        }
556
    }
557
}
558

    
559
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
560
                                    mant_groups *m)
561
{
562
    if (!s->channel_uses_aht[ch]) {
563
        ac3_decode_transform_coeffs_ch(s, ch, m);
564
    } else {
565
        /* if AHT is used, mantissas for all blocks are encoded in the first
566
           block of the frame. */
567
        int bin;
568
        if (!blk)
569
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
570
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
571
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
572
        }
573
    }
574
}
575

    
576
/**
577
 * Decode the transform coefficients.
578
 */
579
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
580
{
581
    int ch, end;
582
    int got_cplchan = 0;
583
    mant_groups m;
584

    
585
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
586

    
587
    for (ch = 1; ch <= s->channels; ch++) {
588
        /* transform coefficients for full-bandwidth channel */
589
        decode_transform_coeffs_ch(s, blk, ch, &m);
590
        /* tranform coefficients for coupling channel come right after the
591
           coefficients for the first coupled channel*/
592
        if (s->channel_in_cpl[ch])  {
593
            if (!got_cplchan) {
594
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
595
                calc_transform_coeffs_cpl(s);
596
                got_cplchan = 1;
597
            }
598
            end = s->end_freq[CPL_CH];
599
        } else {
600
            end = s->end_freq[ch];
601
        }
602
        do
603
            s->fixed_coeffs[ch][end] = 0;
604
        while(++end < 256);
605
    }
606

    
607
    /* zero the dithered coefficients for appropriate channels */
608
    remove_dithering(s);
609
}
610

    
611
/**
612
 * Stereo rematrixing.
613
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
614
 */
615
static void do_rematrixing(AC3DecodeContext *s)
616
{
617
    int bnd, i;
618
    int end, bndend;
619
    int tmp0, tmp1;
620

    
621
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
622

    
623
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
624
        if(s->rematrixing_flags[bnd]) {
625
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
626
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
627
                tmp0 = s->fixed_coeffs[1][i];
628
                tmp1 = s->fixed_coeffs[2][i];
629
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
630
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
631
            }
632
        }
633
    }
634
}
635

    
636
/**
637
 * Inverse MDCT Transform.
638
 * Convert frequency domain coefficients to time-domain audio samples.
639
 * reference: Section 7.9.4 Transformation Equations
640
 */
641
static inline void do_imdct(AC3DecodeContext *s, int channels)
642
{
643
    int ch;
644
    float add_bias = s->add_bias;
645
    if(s->out_channels==1 && channels>1)
646
        add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
647

    
648
    for (ch=1; ch<=channels; ch++) {
649
        if (s->block_switch[ch]) {
650
            int i;
651
            float *x = s->tmp_output+128;
652
            for(i=0; i<128; i++)
653
                x[i] = s->transform_coeffs[ch][2*i];
654
            ff_imdct_half(&s->imdct_256, s->tmp_output, x);
655
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
656
            for(i=0; i<128; i++)
657
                x[i] = s->transform_coeffs[ch][2*i+1];
658
            ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
659
        } else {
660
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
661
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
662
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
663
        }
664
    }
665
}
666

    
667
/**
668
 * Downmix the output to mono or stereo.
669
 */
670
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
671
{
672
    int i, j;
673
    float v0, v1;
674
    if(out_ch == 2) {
675
        for(i=0; i<len; i++) {
676
            v0 = v1 = 0.0f;
677
            for(j=0; j<in_ch; j++) {
678
                v0 += samples[j][i] * matrix[j][0];
679
                v1 += samples[j][i] * matrix[j][1];
680
            }
681
            samples[0][i] = v0;
682
            samples[1][i] = v1;
683
        }
684
    } else if(out_ch == 1) {
685
        for(i=0; i<len; i++) {
686
            v0 = 0.0f;
687
            for(j=0; j<in_ch; j++)
688
                v0 += samples[j][i] * matrix[j][0];
689
            samples[0][i] = v0;
690
        }
691
    }
692
}
693

    
694
/**
695
 * Upmix delay samples from stereo to original channel layout.
696
 */
697
static void ac3_upmix_delay(AC3DecodeContext *s)
698
{
699
    int channel_data_size = sizeof(s->delay[0]);
700
    switch(s->channel_mode) {
701
        case AC3_CHMODE_DUALMONO:
702
        case AC3_CHMODE_STEREO:
703
            /* upmix mono to stereo */
704
            memcpy(s->delay[1], s->delay[0], channel_data_size);
705
            break;
706
        case AC3_CHMODE_2F2R:
707
            memset(s->delay[3], 0, channel_data_size);
708
        case AC3_CHMODE_2F1R:
709
            memset(s->delay[2], 0, channel_data_size);
710
            break;
711
        case AC3_CHMODE_3F2R:
712
            memset(s->delay[4], 0, channel_data_size);
713
        case AC3_CHMODE_3F1R:
714
            memset(s->delay[3], 0, channel_data_size);
715
        case AC3_CHMODE_3F:
716
            memcpy(s->delay[2], s->delay[1], channel_data_size);
717
            memset(s->delay[1], 0, channel_data_size);
718
            break;
719
    }
720
}
721

    
722
/**
723
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
724
 * @param[in] gbc bit reader context
725
 * @param[in] blk block number
726
 * @param[in] eac3 flag to indicate E-AC-3
727
 * @param[in] ecpl flag to indicate enhanced coupling
728
 * @param[in] start_subband subband number for start of range
729
 * @param[in] end_subband subband number for end of range
730
 * @param[in] default_band_struct default band structure table
731
 * @param[out] band_struct decoded band structure
732
 * @param[out] num_subbands number of subbands (optionally NULL)
733
 * @param[out] num_bands number of bands (optionally NULL)
734
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
735
 */
736
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
737
                                  int ecpl, int start_subband, int end_subband,
738
                                  const uint8_t *default_band_struct,
739
                                  uint8_t *band_struct, int *num_subbands,
740
                                  int *num_bands, uint8_t *band_sizes)
741
{
742
    int subbnd, bnd, n_subbands, n_bands=0;
743
    uint8_t bnd_sz[22];
744

    
745
    n_subbands = end_subband - start_subband;
746

    
747
    /* decode band structure from bitstream or use default */
748
    if (!eac3 || get_bits1(gbc)) {
749
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
750
            band_struct[subbnd] = get_bits1(gbc);
751
        }
752
    } else if (!blk) {
753
        memcpy(band_struct,
754
               &default_band_struct[start_subband+1],
755
               n_subbands-1);
756
    }
757
    band_struct[n_subbands-1] = 0;
758

    
759
    /* calculate number of bands and band sizes based on band structure.
760
       note that the first 4 subbands in enhanced coupling span only 6 bins
761
       instead of 12. */
762
    if (num_bands || band_sizes ) {
763
        n_bands = n_subbands;
764
        bnd_sz[0] = ecpl ? 6 : 12;
765
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
766
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
767
            if (band_struct[subbnd-1]) {
768
                n_bands--;
769
                bnd_sz[bnd] += subbnd_size;
770
            } else {
771
                bnd_sz[++bnd] = subbnd_size;
772
            }
773
        }
774
    }
775

    
776
    /* set optional output params */
777
    if (num_subbands)
778
        *num_subbands = n_subbands;
779
    if (num_bands)
780
        *num_bands = n_bands;
781
    if (band_sizes)
782
        memcpy(band_sizes, bnd_sz, n_bands);
783
}
784

    
785
/**
786
 * Decode a single audio block from the AC-3 bitstream.
787
 */
788
static int decode_audio_block(AC3DecodeContext *s, int blk)
789
{
790
    int fbw_channels = s->fbw_channels;
791
    int channel_mode = s->channel_mode;
792
    int i, bnd, seg, ch;
793
    int different_transforms;
794
    int downmix_output;
795
    int cpl_in_use;
796
    GetBitContext *gbc = &s->gbc;
797
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
798

    
799
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
800

    
801
    /* block switch flags */
802
    different_transforms = 0;
803
    if (s->block_switch_syntax) {
804
        for (ch = 1; ch <= fbw_channels; ch++) {
805
            s->block_switch[ch] = get_bits1(gbc);
806
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
807
                different_transforms = 1;
808
        }
809
    }
810

    
811
    /* dithering flags */
812
    if (s->dither_flag_syntax) {
813
        for (ch = 1; ch <= fbw_channels; ch++) {
814
            s->dither_flag[ch] = get_bits1(gbc);
815
        }
816
    }
817

    
818
    /* dynamic range */
819
    i = !(s->channel_mode);
820
    do {
821
        if(get_bits1(gbc)) {
822
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
823
                                  s->avctx->drc_scale)+1.0;
824
        } else if(blk == 0) {
825
            s->dynamic_range[i] = 1.0f;
826
        }
827
    } while(i--);
828

    
829
    /* spectral extension strategy */
830
    if (s->eac3 && (!blk || get_bits1(gbc))) {
831
        if (get_bits1(gbc)) {
832
            ff_log_missing_feature(s->avctx, "Spectral extension", 1);
833
            return -1;
834
        }
835
        /* TODO: parse spectral extension strategy info */
836
    }
837

    
838
    /* TODO: spectral extension coordinates */
839

    
840
    /* coupling strategy */
841
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
842
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
843
        if (!s->eac3)
844
            s->cpl_in_use[blk] = get_bits1(gbc);
845
        if (s->cpl_in_use[blk]) {
846
            /* coupling in use */
847
            int cpl_start_subband, cpl_end_subband;
848

    
849
            if (channel_mode < AC3_CHMODE_STEREO) {
850
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
851
                return -1;
852
            }
853

    
854
            /* check for enhanced coupling */
855
            if (s->eac3 && get_bits1(gbc)) {
856
                /* TODO: parse enhanced coupling strategy info */
857
                ff_log_missing_feature(s->avctx, "Enhanced coupling", 1);
858
                return -1;
859
            }
860

    
861
            /* determine which channels are coupled */
862
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
863
                s->channel_in_cpl[1] = 1;
864
                s->channel_in_cpl[2] = 1;
865
            } else {
866
                for (ch = 1; ch <= fbw_channels; ch++)
867
                    s->channel_in_cpl[ch] = get_bits1(gbc);
868
            }
869

    
870
            /* phase flags in use */
871
            if (channel_mode == AC3_CHMODE_STEREO)
872
                s->phase_flags_in_use = get_bits1(gbc);
873

    
874
            /* coupling frequency range */
875
            /* TODO: modify coupling end freq if spectral extension is used */
876
            cpl_start_subband = get_bits(gbc, 4);
877
            cpl_end_subband   = get_bits(gbc, 4) + 3;
878
            s->num_cpl_subbands = cpl_end_subband - cpl_start_subband;
879
            if (s->num_cpl_subbands < 0) {
880
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d > %d)\n",
881
                       cpl_start_subband, cpl_end_subband);
882
                return -1;
883
            }
884
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
885
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
886

    
887
           decode_band_structure(gbc, blk, s->eac3, 0,
888
                                 cpl_start_subband, cpl_end_subband,
889
                                 ff_eac3_default_cpl_band_struct,
890
                                 s->cpl_band_struct, &s->num_cpl_subbands,
891
                                 &s->num_cpl_bands, NULL);
892
        } else {
893
            /* coupling not in use */
894
            for (ch = 1; ch <= fbw_channels; ch++) {
895
                s->channel_in_cpl[ch] = 0;
896
                s->first_cpl_coords[ch] = 1;
897
            }
898
            s->first_cpl_leak = s->eac3;
899
            s->phase_flags_in_use = 0;
900
        }
901
    } else if (!s->eac3) {
902
        if(!blk) {
903
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
904
            return -1;
905
        } else {
906
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
907
        }
908
    }
909
    cpl_in_use = s->cpl_in_use[blk];
910

    
911
    /* coupling coordinates */
912
    if (cpl_in_use) {
913
        int cpl_coords_exist = 0;
914

    
915
        for (ch = 1; ch <= fbw_channels; ch++) {
916
            if (s->channel_in_cpl[ch]) {
917
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
918
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
919
                    s->first_cpl_coords[ch] = 0;
920
                    cpl_coords_exist = 1;
921
                    master_cpl_coord = 3 * get_bits(gbc, 2);
922
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
923
                        cpl_coord_exp = get_bits(gbc, 4);
924
                        cpl_coord_mant = get_bits(gbc, 4);
925
                        if (cpl_coord_exp == 15)
926
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
927
                        else
928
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
929
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
930
                    }
931
                } else if (!blk) {
932
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
933
                    return -1;
934
                }
935
            } else {
936
                /* channel not in coupling */
937
                s->first_cpl_coords[ch] = 1;
938
            }
939
        }
940
        /* phase flags */
941
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
942
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
943
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
944
            }
945
        }
946
    }
947

    
948
    /* stereo rematrixing strategy and band structure */
949
    if (channel_mode == AC3_CHMODE_STEREO) {
950
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
951
            s->num_rematrixing_bands = 4;
952
            if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
953
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
954
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
955
                s->rematrixing_flags[bnd] = get_bits1(gbc);
956
        } else if (!blk) {
957
            av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
958
            return -1;
959
        }
960
    }
961

    
962
    /* exponent strategies for each channel */
963
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
964
        if (!s->eac3)
965
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
966
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
967
            bit_alloc_stages[ch] = 3;
968
    }
969

    
970
    /* channel bandwidth */
971
    for (ch = 1; ch <= fbw_channels; ch++) {
972
        s->start_freq[ch] = 0;
973
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
974
            int group_size;
975
            int prev = s->end_freq[ch];
976
            if (s->channel_in_cpl[ch])
977
                s->end_freq[ch] = s->start_freq[CPL_CH];
978
            else {
979
                int bandwidth_code = get_bits(gbc, 6);
980
                if (bandwidth_code > 60) {
981
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
982
                    return -1;
983
                }
984
                s->end_freq[ch] = bandwidth_code * 3 + 73;
985
            }
986
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
987
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
988
            if(blk > 0 && s->end_freq[ch] != prev)
989
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
990
        }
991
    }
992
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
993
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
994
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
995
    }
996

    
997
    /* decode exponents for each channel */
998
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
999
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1000
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1001
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1002
                                 s->num_exp_groups[ch], s->dexps[ch][0],
1003
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1004
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1005
                return -1;
1006
            }
1007
            if(ch != CPL_CH && ch != s->lfe_ch)
1008
                skip_bits(gbc, 2); /* skip gainrng */
1009
        }
1010
    }
1011

    
1012
    /* bit allocation information */
1013
    if (s->bit_allocation_syntax) {
1014
        if (get_bits1(gbc)) {
1015
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1016
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1017
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1018
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1019
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1020
            for(ch=!cpl_in_use; ch<=s->channels; ch++)
1021
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1022
        } else if (!blk) {
1023
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1024
            return -1;
1025
        }
1026
    }
1027

    
1028
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1029
    if(!s->eac3 || !blk){
1030
        if(s->snr_offset_strategy && get_bits1(gbc)) {
1031
            int snr = 0;
1032
            int csnr;
1033
            csnr = (get_bits(gbc, 6) - 15) << 4;
1034
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1035
                /* snr offset */
1036
                if (ch == i || s->snr_offset_strategy == 2)
1037
                    snr = (csnr + get_bits(gbc, 4)) << 2;
1038
                /* run at least last bit allocation stage if snr offset changes */
1039
                if(blk && s->snr_offset[ch] != snr) {
1040
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1041
                }
1042
                s->snr_offset[ch] = snr;
1043

    
1044
                /* fast gain (normal AC-3 only) */
1045
                if (!s->eac3) {
1046
                    int prev = s->fast_gain[ch];
1047
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1048
                    /* run last 2 bit allocation stages if fast gain changes */
1049
                    if(blk && prev != s->fast_gain[ch])
1050
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1051
                }
1052
            }
1053
        } else if (!s->eac3 && !blk) {
1054
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1055
            return -1;
1056
        }
1057
    }
1058

    
1059
    /* fast gain (E-AC-3 only) */
1060
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1061
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1062
            int prev = s->fast_gain[ch];
1063
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1064
            /* run last 2 bit allocation stages if fast gain changes */
1065
            if(blk && prev != s->fast_gain[ch])
1066
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1067
        }
1068
    } else if (s->eac3 && !blk) {
1069
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1070
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1071
    }
1072

    
1073
    /* E-AC-3 to AC-3 converter SNR offset */
1074
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1075
        skip_bits(gbc, 10); // skip converter snr offset
1076
    }
1077

    
1078
    /* coupling leak information */
1079
    if (cpl_in_use) {
1080
        if (s->first_cpl_leak || get_bits1(gbc)) {
1081
            int fl = get_bits(gbc, 3);
1082
            int sl = get_bits(gbc, 3);
1083
            /* run last 2 bit allocation stages for coupling channel if
1084
               coupling leak changes */
1085
            if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1086
                       sl != s->bit_alloc_params.cpl_slow_leak)) {
1087
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1088
            }
1089
            s->bit_alloc_params.cpl_fast_leak = fl;
1090
            s->bit_alloc_params.cpl_slow_leak = sl;
1091
        } else if (!s->eac3 && !blk) {
1092
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1093
            return -1;
1094
        }
1095
        s->first_cpl_leak = 0;
1096
    }
1097

    
1098
    /* delta bit allocation information */
1099
    if (s->dba_syntax && get_bits1(gbc)) {
1100
        /* delta bit allocation exists (strategy) */
1101
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1102
            s->dba_mode[ch] = get_bits(gbc, 2);
1103
            if (s->dba_mode[ch] == DBA_RESERVED) {
1104
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1105
                return -1;
1106
            }
1107
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1108
        }
1109
        /* channel delta offset, len and bit allocation */
1110
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1111
            if (s->dba_mode[ch] == DBA_NEW) {
1112
                s->dba_nsegs[ch] = get_bits(gbc, 3);
1113
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1114
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1115
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1116
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1117
                }
1118
                /* run last 2 bit allocation stages if new dba values */
1119
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1120
            }
1121
        }
1122
    } else if(blk == 0) {
1123
        for(ch=0; ch<=s->channels; ch++) {
1124
            s->dba_mode[ch] = DBA_NONE;
1125
        }
1126
    }
1127

    
1128
    /* Bit allocation */
1129
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1130
        if(bit_alloc_stages[ch] > 2) {
1131
            /* Exponent mapping into PSD and PSD integration */
1132
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1133
                                      s->start_freq[ch], s->end_freq[ch],
1134
                                      s->psd[ch], s->band_psd[ch]);
1135
        }
1136
        if(bit_alloc_stages[ch] > 1) {
1137
            /* Compute excitation function, Compute masking curve, and
1138
               Apply delta bit allocation */
1139
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1140
                                           s->start_freq[ch], s->end_freq[ch],
1141
                                           s->fast_gain[ch], (ch == s->lfe_ch),
1142
                                           s->dba_mode[ch], s->dba_nsegs[ch],
1143
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1144
                                           s->dba_values[ch], s->mask[ch])) {
1145
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1146
                return -1;
1147
            }
1148
        }
1149
        if(bit_alloc_stages[ch] > 0) {
1150
            /* Compute bit allocation */
1151
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1152
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1153
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1154
                                      s->start_freq[ch], s->end_freq[ch],
1155
                                      s->snr_offset[ch],
1156
                                      s->bit_alloc_params.floor,
1157
                                      bap_tab, s->bap[ch]);
1158
        }
1159
    }
1160

    
1161
    /* unused dummy data */
1162
    if (s->skip_syntax && get_bits1(gbc)) {
1163
        int skipl = get_bits(gbc, 9);
1164
        while(skipl--)
1165
            skip_bits(gbc, 8);
1166
    }
1167

    
1168
    /* unpack the transform coefficients
1169
       this also uncouples channels if coupling is in use. */
1170
    decode_transform_coeffs(s, blk);
1171

    
1172
    /* TODO: generate enhanced coupling coordinates and uncouple */
1173

    
1174
    /* TODO: apply spectral extension */
1175

    
1176
    /* recover coefficients if rematrixing is in use */
1177
    if(s->channel_mode == AC3_CHMODE_STEREO)
1178
        do_rematrixing(s);
1179

    
1180
    /* apply scaling to coefficients (headroom, dynrng) */
1181
    for(ch=1; ch<=s->channels; ch++) {
1182
        float gain = s->mul_bias / 4194304.0f;
1183
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1184
            gain *= s->dynamic_range[ch-1];
1185
        } else {
1186
            gain *= s->dynamic_range[0];
1187
        }
1188
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1189
    }
1190

    
1191
    /* downmix and MDCT. order depends on whether block switching is used for
1192
       any channel in this block. this is because coefficients for the long
1193
       and short transforms cannot be mixed. */
1194
    downmix_output = s->channels != s->out_channels &&
1195
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1196
                     s->fbw_channels == s->out_channels);
1197
    if(different_transforms) {
1198
        /* the delay samples have already been downmixed, so we upmix the delay
1199
           samples in order to reconstruct all channels before downmixing. */
1200
        if(s->downmixed) {
1201
            s->downmixed = 0;
1202
            ac3_upmix_delay(s);
1203
        }
1204

    
1205
        do_imdct(s, s->channels);
1206

    
1207
        if(downmix_output) {
1208
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1209
        }
1210
    } else {
1211
        if(downmix_output) {
1212
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1213
        }
1214

    
1215
        if(downmix_output && !s->downmixed) {
1216
            s->downmixed = 1;
1217
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1218
        }
1219

    
1220
        do_imdct(s, s->out_channels);
1221
    }
1222

    
1223
    return 0;
1224
}
1225

    
1226
/**
1227
 * Decode a single AC-3 frame.
1228
 */
1229
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1230
                            AVPacket *avpkt)
1231
{
1232
    const uint8_t *buf = avpkt->data;
1233
    int buf_size = avpkt->size;
1234
    AC3DecodeContext *s = avctx->priv_data;
1235
    int16_t *out_samples = (int16_t *)data;
1236
    int blk, ch, err;
1237
    const uint8_t *channel_map;
1238

    
1239
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1240
    if (s->input_buffer) {
1241
        /* copy input buffer to decoder context to avoid reading past the end
1242
           of the buffer, which can be caused by a damaged input stream. */
1243
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1244
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1245
    } else {
1246
        init_get_bits(&s->gbc, buf, buf_size * 8);
1247
    }
1248

    
1249
    /* parse the syncinfo */
1250
    *data_size = 0;
1251
    err = parse_frame_header(s);
1252

    
1253
    /* check that reported frame size fits in input buffer */
1254
    if(s->frame_size > buf_size) {
1255
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1256
        err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1257
    }
1258

    
1259
    /* check for crc mismatch */
1260
    if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
1261
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1262
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1263
            err = AAC_AC3_PARSE_ERROR_CRC;
1264
        }
1265
    }
1266

    
1267
    if(err && err != AAC_AC3_PARSE_ERROR_CRC) {
1268
        switch(err) {
1269
            case AAC_AC3_PARSE_ERROR_SYNC:
1270
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1271
                return -1;
1272
            case AAC_AC3_PARSE_ERROR_BSID:
1273
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1274
                break;
1275
            case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1276
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1277
                break;
1278
            case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1279
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1280
                break;
1281
            case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1282
                /* skip frame if CRC is ok. otherwise use error concealment. */
1283
                /* TODO: add support for substreams and dependent frames */
1284
                if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1285
                    av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1286
                    return s->frame_size;
1287
                } else {
1288
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1289
                }
1290
                break;
1291
            default:
1292
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1293
                break;
1294
        }
1295
    }
1296

    
1297
    /* if frame is ok, set audio parameters */
1298
    if (!err) {
1299
        avctx->sample_rate = s->sample_rate;
1300
        avctx->bit_rate = s->bit_rate;
1301

    
1302
        /* channel config */
1303
        s->out_channels = s->channels;
1304
        s->output_mode = s->channel_mode;
1305
        if(s->lfe_on)
1306
            s->output_mode |= AC3_OUTPUT_LFEON;
1307
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1308
                avctx->request_channels < s->channels) {
1309
            s->out_channels = avctx->request_channels;
1310
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1311
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1312
        }
1313
        avctx->channels = s->out_channels;
1314
        avctx->channel_layout = s->channel_layout;
1315

    
1316
        /* set downmixing coefficients if needed */
1317
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1318
                s->fbw_channels == s->out_channels)) {
1319
            set_downmix_coeffs(s);
1320
        }
1321
    } else if (!s->out_channels) {
1322
        s->out_channels = avctx->channels;
1323
        if(s->out_channels < s->channels)
1324
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1325
    }
1326

    
1327
    /* decode the audio blocks */
1328
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1329
    for (blk = 0; blk < s->num_blocks; blk++) {
1330
        const float *output[s->out_channels];
1331
        if (!err && decode_audio_block(s, blk)) {
1332
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1333
            err = 1;
1334
        }
1335
        for (ch = 0; ch < s->out_channels; ch++)
1336
            output[ch] = s->output[channel_map[ch]];
1337
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1338
        out_samples += 256 * s->out_channels;
1339
    }
1340
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1341
    return s->frame_size;
1342
}
1343

    
1344
/**
1345
 * Uninitialize the AC-3 decoder.
1346
 */
1347
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1348
{
1349
    AC3DecodeContext *s = avctx->priv_data;
1350
    ff_mdct_end(&s->imdct_512);
1351
    ff_mdct_end(&s->imdct_256);
1352

    
1353
    av_freep(&s->input_buffer);
1354

    
1355
    return 0;
1356
}
1357

    
1358
AVCodec ac3_decoder = {
1359
    .name = "ac3",
1360
    .type = CODEC_TYPE_AUDIO,
1361
    .id = CODEC_ID_AC3,
1362
    .priv_data_size = sizeof (AC3DecodeContext),
1363
    .init = ac3_decode_init,
1364
    .close = ac3_decode_end,
1365
    .decode = ac3_decode_frame,
1366
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1367
};
1368

    
1369
AVCodec eac3_decoder = {
1370
    .name = "eac3",
1371
    .type = CODEC_TYPE_AUDIO,
1372
    .id = CODEC_ID_EAC3,
1373
    .priv_data_size = sizeof (AC3DecodeContext),
1374
    .init = ac3_decode_init,
1375
    .close = ac3_decode_end,
1376
    .decode = ac3_decode_frame,
1377
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1378
};