Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ d1515324

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
 * This file is part of FFmpeg.
11
 *
12
 * FFmpeg is free software; you can redistribute it and/or
13
 * modify it under the terms of the GNU Lesser General Public
14
 * License as published by the Free Software Foundation; either
15
 * version 2.1 of the License, or (at your option) any later version.
16
 *
17
 * FFmpeg is distributed in the hope that it will be useful,
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 * Lesser General Public License for more details.
21
 *
22
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with FFmpeg; if not, write to the Free Software
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25
 */
26

    
27
#include <stdio.h>
28
#include <stddef.h>
29
#include <math.h>
30
#include <string.h>
31

    
32
#include "libavutil/crc.h"
33
#include "internal.h"
34
#include "aac_ac3_parser.h"
35
#include "ac3_parser.h"
36
#include "ac3dec.h"
37
#include "ac3dec_data.h"
38

    
39
/** Large enough for maximum possible frame size when the specification limit is ignored */
40
#define AC3_FRAME_BUFFER_SIZE 32768
41

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

    
48

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

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

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

    
68
/** Adjustments in dB gain */
69
#define LEVEL_PLUS_3DB          1.4142135623730950
70
#define LEVEL_PLUS_1POINT5DB    1.1892071150027209
71
#define LEVEL_MINUS_1POINT5DB   0.8408964152537145
72
#define LEVEL_MINUS_3DB         0.7071067811865476
73
#define LEVEL_MINUS_4POINT5DB   0.5946035575013605
74
#define LEVEL_MINUS_6DB         0.5000000000000000
75
#define LEVEL_MINUS_9DB         0.3535533905932738
76
#define LEVEL_ZERO              0.0000000000000000
77
#define LEVEL_ONE               1.0000000000000000
78

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

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

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

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

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

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

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

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

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

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

    
181

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

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

    
198
    /* set bias values for float to int16 conversion */
199
    if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
200
        s->add_bias = 385.0f;
201
        s->mul_bias = 1.0f;
202
    } else {
203
        s->add_bias = 0.0f;
204
        s->mul_bias = 32767.0f;
205
    }
206

    
207
    /* allow downmixing to stereo or mono */
208
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
209
            avctx->request_channels < avctx->channels &&
210
            avctx->request_channels <= 2) {
211
        avctx->channels = avctx->request_channels;
212
    }
213
    s->downmixed = 1;
214

    
215
    /* allocate context input buffer */
216
    if (avctx->error_recognition >= FF_ER_CAREFUL) {
217
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
218
        if (!s->input_buffer)
219
            return AVERROR_NOMEM;
220
    }
221

    
222
    avctx->sample_fmt = SAMPLE_FMT_S16;
223
    return 0;
224
}
225

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

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

    
248
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
249

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

    
257
    /* skip additional bitstream info */
258
    if (get_bits1(gbc)) {
259
        i = get_bits(gbc, 6);
260
        do {
261
            skip_bits(gbc, 8);
262
        } while(i--);
263
    }
264

    
265
    return 0;
266
}
267

    
268
/**
269
 * Common function to parse AC-3 or E-AC-3 frame header
270
 */
271
static int parse_frame_header(AC3DecodeContext *s)
272
{
273
    AC3HeaderInfo hdr;
274
    int err;
275

    
276
    err = ff_ac3_parse_header(&s->gbc, &hdr);
277
    if(err)
278
        return err;
279

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

    
298
    if(s->lfe_on) {
299
        s->start_freq[s->lfe_ch] = 0;
300
        s->end_freq[s->lfe_ch] = 7;
301
        s->num_exp_groups[s->lfe_ch] = 2;
302
        s->channel_in_cpl[s->lfe_ch] = 0;
303
    }
304

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
582
    m.b1 = m.b2 = m.b4 = 0;
583

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

    
604
    /* zero the dithered coefficients for appropriate channels */
605
    remove_dithering(s);
606
}
607

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

    
618
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
619

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

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

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

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

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

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

    
741
    n_subbands = end_subband - start_subband;
742

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

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

    
772
    /* set optional output params */
773
    if (num_bands)
774
        *num_bands = n_bands;
775
    if (band_sizes)
776
        memcpy(band_sizes, bnd_sz, n_bands);
777
}
778

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

    
793
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
794

    
795
    /* block switch flags */
796
    different_transforms = 0;
797
    if (s->block_switch_syntax) {
798
        for (ch = 1; ch <= fbw_channels; ch++) {
799
            s->block_switch[ch] = get_bits1(gbc);
800
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
801
                different_transforms = 1;
802
        }
803
    }
804

    
805
    /* dithering flags */
806
    if (s->dither_flag_syntax) {
807
        for (ch = 1; ch <= fbw_channels; ch++) {
808
            s->dither_flag[ch] = get_bits1(gbc);
809
        }
810
    }
811

    
812
    /* dynamic range */
813
    i = !(s->channel_mode);
814
    do {
815
        if(get_bits1(gbc)) {
816
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
817
                                  s->avctx->drc_scale)+1.0;
818
        } else if(blk == 0) {
819
            s->dynamic_range[i] = 1.0f;
820
        }
821
    } while(i--);
822

    
823
    /* spectral extension strategy */
824
    if (s->eac3 && (!blk || get_bits1(gbc))) {
825
        if (get_bits1(gbc)) {
826
            av_log_missing_feature(s->avctx, "Spectral extension", 1);
827
            return -1;
828
        }
829
        /* TODO: parse spectral extension strategy info */
830
    }
831

    
832
    /* TODO: spectral extension coordinates */
833

    
834
    /* coupling strategy */
835
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
836
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
837
        if (!s->eac3)
838
            s->cpl_in_use[blk] = get_bits1(gbc);
839
        if (s->cpl_in_use[blk]) {
840
            /* coupling in use */
841
            int cpl_start_subband, cpl_end_subband;
842

    
843
            if (channel_mode < AC3_CHMODE_STEREO) {
844
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
845
                return -1;
846
            }
847

    
848
            /* check for enhanced coupling */
849
            if (s->eac3 && get_bits1(gbc)) {
850
                /* TODO: parse enhanced coupling strategy info */
851
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
852
                return -1;
853
            }
854

    
855
            /* determine which channels are coupled */
856
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
857
                s->channel_in_cpl[1] = 1;
858
                s->channel_in_cpl[2] = 1;
859
            } else {
860
                for (ch = 1; ch <= fbw_channels; ch++)
861
                    s->channel_in_cpl[ch] = get_bits1(gbc);
862
            }
863

    
864
            /* phase flags in use */
865
            if (channel_mode == AC3_CHMODE_STEREO)
866
                s->phase_flags_in_use = get_bits1(gbc);
867

    
868
            /* coupling frequency range */
869
            /* TODO: modify coupling end freq if spectral extension is used */
870
            cpl_start_subband = get_bits(gbc, 4);
871
            cpl_end_subband   = get_bits(gbc, 4) + 3;
872
            if (cpl_start_subband >= cpl_end_subband) {
873
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
874
                       cpl_start_subband, cpl_end_subband);
875
                return -1;
876
            }
877
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
878
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
879

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

    
903
    /* coupling coordinates */
904
    if (cpl_in_use) {
905
        int cpl_coords_exist = 0;
906

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

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

    
954
    /* exponent strategies for each channel */
955
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
956
        if (!s->eac3)
957
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
958
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
959
            bit_alloc_stages[ch] = 3;
960
    }
961

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

    
989
    /* decode exponents for each channel */
990
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
991
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
992
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
993
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
994
                                 s->num_exp_groups[ch], s->dexps[ch][0],
995
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
996
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
997
                return -1;
998
            }
999
            if(ch != CPL_CH && ch != s->lfe_ch)
1000
                skip_bits(gbc, 2); /* skip gainrng */
1001
        }
1002
    }
1003

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

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

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

    
1051
    /* fast gain (E-AC-3 only) */
1052
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1053
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1054
            int prev = s->fast_gain[ch];
1055
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1056
            /* run last 2 bit allocation stages if fast gain changes */
1057
            if(blk && prev != s->fast_gain[ch])
1058
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1059
        }
1060
    } else if (s->eac3 && !blk) {
1061
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1062
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1063
    }
1064

    
1065
    /* E-AC-3 to AC-3 converter SNR offset */
1066
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1067
        skip_bits(gbc, 10); // skip converter snr offset
1068
    }
1069

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

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

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

    
1153
    /* unused dummy data */
1154
    if (s->skip_syntax && get_bits1(gbc)) {
1155
        int skipl = get_bits(gbc, 9);
1156
        while(skipl--)
1157
            skip_bits(gbc, 8);
1158
    }
1159

    
1160
    /* unpack the transform coefficients
1161
       this also uncouples channels if coupling is in use. */
1162
    decode_transform_coeffs(s, blk);
1163

    
1164
    /* TODO: generate enhanced coupling coordinates and uncouple */
1165

    
1166
    /* TODO: apply spectral extension */
1167

    
1168
    /* recover coefficients if rematrixing is in use */
1169
    if(s->channel_mode == AC3_CHMODE_STEREO)
1170
        do_rematrixing(s);
1171

    
1172
    /* apply scaling to coefficients (headroom, dynrng) */
1173
    for(ch=1; ch<=s->channels; ch++) {
1174
        float gain = s->mul_bias / 4194304.0f;
1175
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1176
            gain *= s->dynamic_range[ch-1];
1177
        } else {
1178
            gain *= s->dynamic_range[0];
1179
        }
1180
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1181
    }
1182

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

    
1197
        do_imdct(s, s->channels);
1198

    
1199
        if(downmix_output) {
1200
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1201
        }
1202
    } else {
1203
        if(downmix_output) {
1204
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1205
        }
1206

    
1207
        if(downmix_output && !s->downmixed) {
1208
            s->downmixed = 1;
1209
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1210
        }
1211

    
1212
        do_imdct(s, s->out_channels);
1213
    }
1214

    
1215
    return 0;
1216
}
1217

    
1218
/**
1219
 * Decode a single AC-3 frame.
1220
 */
1221
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1222
                            AVPacket *avpkt)
1223
{
1224
    const uint8_t *buf = avpkt->data;
1225
    int buf_size = avpkt->size;
1226
    AC3DecodeContext *s = avctx->priv_data;
1227
    int16_t *out_samples = (int16_t *)data;
1228
    int blk, ch, err;
1229
    const uint8_t *channel_map;
1230
    const float *output[AC3_MAX_CHANNELS];
1231

    
1232
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1233
    if (s->input_buffer) {
1234
        /* copy input buffer to decoder context to avoid reading past the end
1235
           of the buffer, which can be caused by a damaged input stream. */
1236
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1237
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1238
    } else {
1239
        init_get_bits(&s->gbc, buf, buf_size * 8);
1240
    }
1241

    
1242
    /* parse the syncinfo */
1243
    *data_size = 0;
1244
    err = parse_frame_header(s);
1245

    
1246
    /* check that reported frame size fits in input buffer */
1247
    if(s->frame_size > buf_size) {
1248
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1249
        err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1250
    }
1251

    
1252
    /* check for crc mismatch */
1253
    if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
1254
        if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1255
            av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1256
            err = AAC_AC3_PARSE_ERROR_CRC;
1257
        }
1258
    }
1259

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

    
1290
    /* if frame is ok, set audio parameters */
1291
    if (!err) {
1292
        avctx->sample_rate = s->sample_rate;
1293
        avctx->bit_rate = s->bit_rate;
1294

    
1295
        /* channel config */
1296
        s->out_channels = s->channels;
1297
        s->output_mode = s->channel_mode;
1298
        if(s->lfe_on)
1299
            s->output_mode |= AC3_OUTPUT_LFEON;
1300
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1301
                avctx->request_channels < s->channels) {
1302
            s->out_channels = avctx->request_channels;
1303
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1304
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1305
        }
1306
        avctx->channels = s->out_channels;
1307
        avctx->channel_layout = s->channel_layout;
1308

    
1309
        /* set downmixing coefficients if needed */
1310
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1311
                s->fbw_channels == s->out_channels)) {
1312
            set_downmix_coeffs(s);
1313
        }
1314
    } else if (!s->out_channels) {
1315
        s->out_channels = avctx->channels;
1316
        if(s->out_channels < s->channels)
1317
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1318
    }
1319

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

    
1336
/**
1337
 * Uninitialize the AC-3 decoder.
1338
 */
1339
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1340
{
1341
    AC3DecodeContext *s = avctx->priv_data;
1342
    ff_mdct_end(&s->imdct_512);
1343
    ff_mdct_end(&s->imdct_256);
1344

    
1345
    av_freep(&s->input_buffer);
1346

    
1347
    return 0;
1348
}
1349

    
1350
AVCodec ac3_decoder = {
1351
    .name = "ac3",
1352
    .type = CODEC_TYPE_AUDIO,
1353
    .id = CODEC_ID_AC3,
1354
    .priv_data_size = sizeof (AC3DecodeContext),
1355
    .init = ac3_decode_init,
1356
    .close = ac3_decode_end,
1357
    .decode = ac3_decode_frame,
1358
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1359
};
1360

    
1361
#if CONFIG_EAC3_DECODER
1362
AVCodec eac3_decoder = {
1363
    .name = "eac3",
1364
    .type = CODEC_TYPE_AUDIO,
1365
    .id = CODEC_ID_EAC3,
1366
    .priv_data_size = sizeof (AC3DecodeContext),
1367
    .init = ac3_decode_init,
1368
    .close = ac3_decode_end,
1369
    .decode = ac3_decode_frame,
1370
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1371
};
1372
#endif