Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 991f3de1

History | View | Annotate | Download (51.9 KB)

1
/*
2
 * AC-3 Audio Decoder
3
 * This code was developed as part of Google Summer of Code 2006.
4
 * E-AC-3 support was added as part of Google Summer of Code 2007.
5
 *
6
 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
7
 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8
 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
9
 *
10
 * This file is part of Libav.
11
 *
12
 * Libav is free software; you can redistribute it and/or
13
 * modify it under the terms of the GNU Lesser General Public
14
 * License as published by the Free Software Foundation; either
15
 * version 2.1 of the License, or (at your option) any later version.
16
 *
17
 * Libav is distributed in the hope that it will be useful,
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 * Lesser General Public License for more details.
21
 *
22
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with Libav; if not, write to the Free Software
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25
 */
26

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

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

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

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

    
49

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

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

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

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

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

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

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

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

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

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

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

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

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

    
172

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

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

    
190
    /* set scale value for float to int16 conversion */
191
    s->mul_bias = 32767.0f;
192

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

    
201
    /* allocate context input buffer */
202
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
203
        if (!s->input_buffer)
204
            return AVERROR(ENOMEM);
205

    
206
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
207
    return 0;
208
}
209

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

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

    
232
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
233

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

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

    
249
    return 0;
250
}
251

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

    
260
    err = ff_ac3_parse_header(&s->gbc, &hdr);
261
    if(err)
262
        return err;
263

    
264
    /* get decoding parameters from header info */
265
    s->bit_alloc_params.sr_code     = hdr.sr_code;
266
    s->bitstream_mode               = hdr.bitstream_mode;
267
    s->channel_mode                 = hdr.channel_mode;
268
    s->channel_layout               = hdr.channel_layout;
269
    s->lfe_on                       = hdr.lfe_on;
270
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
271
    s->sample_rate                  = hdr.sample_rate;
272
    s->bit_rate                     = hdr.bit_rate;
273
    s->channels                     = hdr.channels;
274
    s->fbw_channels                 = s->channels - s->lfe_on;
275
    s->lfe_ch                       = s->fbw_channels + 1;
276
    s->frame_size                   = hdr.frame_size;
277
    s->center_mix_level             = hdr.center_mix_level;
278
    s->surround_mix_level           = hdr.surround_mix_level;
279
    s->num_blocks                   = hdr.num_blocks;
280
    s->frame_type                   = hdr.frame_type;
281
    s->substreamid                  = hdr.substreamid;
282

    
283
    if(s->lfe_on) {
284
        s->start_freq[s->lfe_ch] = 0;
285
        s->end_freq[s->lfe_ch] = 7;
286
        s->num_exp_groups[s->lfe_ch] = 2;
287
        s->channel_in_cpl[s->lfe_ch] = 0;
288
    }
289

    
290
    if (hdr.bitstream_id <= 10) {
291
        s->eac3                  = 0;
292
        s->snr_offset_strategy   = 2;
293
        s->block_switch_syntax   = 1;
294
        s->dither_flag_syntax    = 1;
295
        s->bit_allocation_syntax = 1;
296
        s->fast_gain_syntax      = 0;
297
        s->first_cpl_leak        = 0;
298
        s->dba_syntax            = 1;
299
        s->skip_syntax           = 1;
300
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
301
        return ac3_parse_header(s);
302
    } else if (CONFIG_EAC3_DECODER) {
303
        s->eac3 = 1;
304
        return ff_eac3_parse_header(s);
305
    } else {
306
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
307
        return -1;
308
    }
309
}
310

    
311
/**
312
 * Set stereo downmixing coefficients based on frame header info.
313
 * reference: Section 7.8.2 Downmixing Into Two Channels
314
 */
315
static void set_downmix_coeffs(AC3DecodeContext *s)
316
{
317
    int i;
318
    float cmix = gain_levels[center_levels[s->center_mix_level]];
319
    float smix = gain_levels[surround_levels[s->surround_mix_level]];
320
    float norm0, norm1;
321

    
322
    for(i=0; i<s->fbw_channels; i++) {
323
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
324
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
325
    }
326
    if(s->channel_mode > 1 && s->channel_mode & 1) {
327
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
328
    }
329
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
330
        int nf = s->channel_mode - 2;
331
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
332
    }
333
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
334
        int nf = s->channel_mode - 4;
335
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
336
    }
337

    
338
    /* renormalize */
339
    norm0 = norm1 = 0.0;
340
    for(i=0; i<s->fbw_channels; i++) {
341
        norm0 += s->downmix_coeffs[i][0];
342
        norm1 += s->downmix_coeffs[i][1];
343
    }
344
    norm0 = 1.0f / norm0;
345
    norm1 = 1.0f / norm1;
346
    for(i=0; i<s->fbw_channels; i++) {
347
        s->downmix_coeffs[i][0] *= norm0;
348
        s->downmix_coeffs[i][1] *= norm1;
349
    }
350

    
351
    if(s->output_mode == AC3_CHMODE_MONO) {
352
        for(i=0; i<s->fbw_channels; i++)
353
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
354
    }
355
}
356

    
357
/**
358
 * Decode the grouped exponents according to exponent strategy.
359
 * reference: Section 7.1.3 Exponent Decoding
360
 */
361
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
362
                            uint8_t absexp, int8_t *dexps)
363
{
364
    int i, j, grp, group_size;
365
    int dexp[256];
366
    int expacc, prevexp;
367

    
368
    /* unpack groups */
369
    group_size = exp_strategy + (exp_strategy == EXP_D45);
370
    for(grp=0,i=0; grp<ngrps; grp++) {
371
        expacc = get_bits(gbc, 7);
372
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
373
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
374
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
375
    }
376

    
377
    /* convert to absolute exps and expand groups */
378
    prevexp = absexp;
379
    for(i=0,j=0; i<ngrps*3; i++) {
380
        prevexp += dexp[i] - 2;
381
        if (prevexp > 24U)
382
            return -1;
383
        switch (group_size) {
384
            case 4: dexps[j++] = prevexp;
385
                    dexps[j++] = prevexp;
386
            case 2: dexps[j++] = prevexp;
387
            case 1: dexps[j++] = prevexp;
388
        }
389
    }
390
    return 0;
391
}
392

    
393
/**
394
 * Generate transform coefficients for each coupled channel in the coupling
395
 * range using the coupling coefficients and coupling coordinates.
396
 * reference: Section 7.4.3 Coupling Coordinate Format
397
 */
398
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
399
{
400
    int bin, band, ch;
401

    
402
    bin = s->start_freq[CPL_CH];
403
    for (band = 0; band < s->num_cpl_bands; band++) {
404
        int band_start = bin;
405
        int band_end = bin + s->cpl_band_sizes[band];
406
        for (ch = 1; ch <= s->fbw_channels; ch++) {
407
            if (s->channel_in_cpl[ch]) {
408
                int cpl_coord = s->cpl_coords[ch][band] << 5;
409
                for (bin = band_start; bin < band_end; bin++) {
410
                    s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
411
                }
412
                if (ch == 2 && s->phase_flags[band]) {
413
                    for (bin = band_start; bin < band_end; bin++)
414
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
415
                }
416
            }
417
        }
418
        bin = band_end;
419
    }
420
}
421

    
422
/**
423
 * Grouped mantissas for 3-level 5-level and 11-level quantization
424
 */
425
typedef struct {
426
    int b1_mant[2];
427
    int b2_mant[2];
428
    int b4_mant;
429
    int b1;
430
    int b2;
431
    int b4;
432
} mant_groups;
433

    
434
/**
435
 * Decode the transform coefficients for a particular channel
436
 * reference: Section 7.3 Quantization and Decoding of Mantissas
437
 */
438
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
439
{
440
    int start_freq = s->start_freq[ch_index];
441
    int end_freq = s->end_freq[ch_index];
442
    uint8_t *baps = s->bap[ch_index];
443
    int8_t *exps = s->dexps[ch_index];
444
    int *coeffs = s->fixed_coeffs[ch_index];
445
    int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
446
    GetBitContext *gbc = &s->gbc;
447
    int freq;
448

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

    
513
/**
514
 * Remove random dithering from coupling range coefficients with zero-bit
515
 * mantissas for coupled channels which do not use dithering.
516
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
517
 */
518
static void remove_dithering(AC3DecodeContext *s) {
519
    int ch, i;
520

    
521
    for(ch=1; ch<=s->fbw_channels; ch++) {
522
        if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
523
            for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
524
                if(!s->bap[CPL_CH][i])
525
                    s->fixed_coeffs[ch][i] = 0;
526
            }
527
        }
528
    }
529
}
530

    
531
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
532
                                    mant_groups *m)
533
{
534
    if (!s->channel_uses_aht[ch]) {
535
        ac3_decode_transform_coeffs_ch(s, ch, m);
536
    } else {
537
        /* if AHT is used, mantissas for all blocks are encoded in the first
538
           block of the frame. */
539
        int bin;
540
        if (!blk && CONFIG_EAC3_DECODER)
541
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
542
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
543
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
544
        }
545
    }
546
}
547

    
548
/**
549
 * Decode the transform coefficients.
550
 */
551
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
552
{
553
    int ch, end;
554
    int got_cplchan = 0;
555
    mant_groups m;
556

    
557
    m.b1 = m.b2 = m.b4 = 0;
558

    
559
    for (ch = 1; ch <= s->channels; ch++) {
560
        /* transform coefficients for full-bandwidth channel */
561
        decode_transform_coeffs_ch(s, blk, ch, &m);
562
        /* tranform coefficients for coupling channel come right after the
563
           coefficients for the first coupled channel*/
564
        if (s->channel_in_cpl[ch])  {
565
            if (!got_cplchan) {
566
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
567
                calc_transform_coeffs_cpl(s);
568
                got_cplchan = 1;
569
            }
570
            end = s->end_freq[CPL_CH];
571
        } else {
572
            end = s->end_freq[ch];
573
        }
574
        do
575
            s->fixed_coeffs[ch][end] = 0;
576
        while(++end < 256);
577
    }
578

    
579
    /* zero the dithered coefficients for appropriate channels */
580
    remove_dithering(s);
581
}
582

    
583
/**
584
 * Stereo rematrixing.
585
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
586
 */
587
static void do_rematrixing(AC3DecodeContext *s)
588
{
589
    int bnd, i;
590
    int end, bndend;
591

    
592
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
593

    
594
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
595
        if(s->rematrixing_flags[bnd]) {
596
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
597
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
598
                int tmp0 = s->fixed_coeffs[1][i];
599
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
600
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
601
            }
602
        }
603
    }
604
}
605

    
606
/**
607
 * Inverse MDCT Transform.
608
 * Convert frequency domain coefficients to time-domain audio samples.
609
 * reference: Section 7.9.4 Transformation Equations
610
 */
611
static inline void do_imdct(AC3DecodeContext *s, int channels)
612
{
613
    int ch;
614

    
615
    for (ch=1; ch<=channels; ch++) {
616
        if (s->block_switch[ch]) {
617
            int i;
618
            float *x = s->tmp_output+128;
619
            for(i=0; i<128; i++)
620
                x[i] = s->transform_coeffs[ch][2*i];
621
            s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
622
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
623
            for(i=0; i<128; i++)
624
                x[i] = s->transform_coeffs[ch][2*i+1];
625
            s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch-1], x);
626
        } else {
627
            s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
628
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
629
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
630
        }
631
    }
632
}
633

    
634
/**
635
 * Downmix the output to mono or stereo.
636
 */
637
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
638
{
639
    int i, j;
640
    float v0, v1;
641
    if(out_ch == 2) {
642
        for(i=0; i<len; i++) {
643
            v0 = v1 = 0.0f;
644
            for(j=0; j<in_ch; j++) {
645
                v0 += samples[j][i] * matrix[j][0];
646
                v1 += samples[j][i] * matrix[j][1];
647
            }
648
            samples[0][i] = v0;
649
            samples[1][i] = v1;
650
        }
651
    } else if(out_ch == 1) {
652
        for(i=0; i<len; i++) {
653
            v0 = 0.0f;
654
            for(j=0; j<in_ch; j++)
655
                v0 += samples[j][i] * matrix[j][0];
656
            samples[0][i] = v0;
657
        }
658
    }
659
}
660

    
661
/**
662
 * Upmix delay samples from stereo to original channel layout.
663
 */
664
static void ac3_upmix_delay(AC3DecodeContext *s)
665
{
666
    int channel_data_size = sizeof(s->delay[0]);
667
    switch(s->channel_mode) {
668
        case AC3_CHMODE_DUALMONO:
669
        case AC3_CHMODE_STEREO:
670
            /* upmix mono to stereo */
671
            memcpy(s->delay[1], s->delay[0], channel_data_size);
672
            break;
673
        case AC3_CHMODE_2F2R:
674
            memset(s->delay[3], 0, channel_data_size);
675
        case AC3_CHMODE_2F1R:
676
            memset(s->delay[2], 0, channel_data_size);
677
            break;
678
        case AC3_CHMODE_3F2R:
679
            memset(s->delay[4], 0, channel_data_size);
680
        case AC3_CHMODE_3F1R:
681
            memset(s->delay[3], 0, channel_data_size);
682
        case AC3_CHMODE_3F:
683
            memcpy(s->delay[2], s->delay[1], channel_data_size);
684
            memset(s->delay[1], 0, channel_data_size);
685
            break;
686
    }
687
}
688

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

    
715
    n_subbands = end_subband - start_subband;
716

    
717
    /* decode band structure from bitstream or use default */
718
    if (!eac3 || get_bits1(gbc)) {
719
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
720
            coded_band_struct[subbnd] = get_bits1(gbc);
721
        }
722
        band_struct = coded_band_struct;
723
    } else if (!blk) {
724
        band_struct = &default_band_struct[start_subband+1];
725
    } else {
726
        /* no change in band structure */
727
        return;
728
    }
729

    
730
    /* calculate number of bands and band sizes based on band structure.
731
       note that the first 4 subbands in enhanced coupling span only 6 bins
732
       instead of 12. */
733
    if (num_bands || band_sizes ) {
734
        n_bands = n_subbands;
735
        bnd_sz[0] = ecpl ? 6 : 12;
736
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
737
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
738
            if (band_struct[subbnd-1]) {
739
                n_bands--;
740
                bnd_sz[bnd] += subbnd_size;
741
            } else {
742
                bnd_sz[++bnd] = subbnd_size;
743
            }
744
        }
745
    }
746

    
747
    /* set optional output params */
748
    if (num_bands)
749
        *num_bands = n_bands;
750
    if (band_sizes)
751
        memcpy(band_sizes, bnd_sz, n_bands);
752
}
753

    
754
/**
755
 * Decode a single audio block from the AC-3 bitstream.
756
 */
757
static int decode_audio_block(AC3DecodeContext *s, int blk)
758
{
759
    int fbw_channels = s->fbw_channels;
760
    int channel_mode = s->channel_mode;
761
    int i, bnd, seg, ch;
762
    int different_transforms;
763
    int downmix_output;
764
    int cpl_in_use;
765
    GetBitContext *gbc = &s->gbc;
766
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
767

    
768
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
769

    
770
    /* block switch flags */
771
    different_transforms = 0;
772
    if (s->block_switch_syntax) {
773
        for (ch = 1; ch <= fbw_channels; ch++) {
774
            s->block_switch[ch] = get_bits1(gbc);
775
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
776
                different_transforms = 1;
777
        }
778
    }
779

    
780
    /* dithering flags */
781
    if (s->dither_flag_syntax) {
782
        for (ch = 1; ch <= fbw_channels; ch++) {
783
            s->dither_flag[ch] = get_bits1(gbc);
784
        }
785
    }
786

    
787
    /* dynamic range */
788
    i = !(s->channel_mode);
789
    do {
790
        if(get_bits1(gbc)) {
791
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
792
                                  s->avctx->drc_scale)+1.0;
793
        } else if(blk == 0) {
794
            s->dynamic_range[i] = 1.0f;
795
        }
796
    } while(i--);
797

    
798
    /* spectral extension strategy */
799
    if (s->eac3 && (!blk || get_bits1(gbc))) {
800
        s->spx_in_use = get_bits1(gbc);
801
        if (s->spx_in_use) {
802
            int dst_start_freq, dst_end_freq, src_start_freq,
803
                start_subband, end_subband;
804

    
805
            /* determine which channels use spx */
806
            if (s->channel_mode == AC3_CHMODE_MONO) {
807
                s->channel_uses_spx[1] = 1;
808
            } else {
809
                for (ch = 1; ch <= fbw_channels; ch++)
810
                    s->channel_uses_spx[ch] = get_bits1(gbc);
811
            }
812

    
813
            /* get the frequency bins of the spx copy region and the spx start
814
               and end subbands */
815
            dst_start_freq = get_bits(gbc, 2);
816
            start_subband  = get_bits(gbc, 3) + 2;
817
            if (start_subband > 7)
818
                start_subband += start_subband - 7;
819
            end_subband    = get_bits(gbc, 3) + 5;
820
            if (end_subband   > 7)
821
                end_subband   += end_subband   - 7;
822
            dst_start_freq = dst_start_freq * 12 + 25;
823
            src_start_freq = start_subband  * 12 + 25;
824
            dst_end_freq   = end_subband    * 12 + 25;
825

    
826
            /* check validity of spx ranges */
827
            if (start_subband >= end_subband) {
828
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
829
                       "range (%d >= %d)\n", start_subband, end_subband);
830
                return -1;
831
            }
832
            if (dst_start_freq >= src_start_freq) {
833
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
834
                       "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
835
                return -1;
836
            }
837

    
838
            s->spx_dst_start_freq = dst_start_freq;
839
            s->spx_src_start_freq = src_start_freq;
840
            s->spx_dst_end_freq   = dst_end_freq;
841

    
842
            decode_band_structure(gbc, blk, s->eac3, 0,
843
                                  start_subband, end_subband,
844
                                  ff_eac3_default_spx_band_struct,
845
                                  &s->num_spx_bands,
846
                                  s->spx_band_sizes);
847
        } else {
848
            for (ch = 1; ch <= fbw_channels; ch++) {
849
                s->channel_uses_spx[ch] = 0;
850
                s->first_spx_coords[ch] = 1;
851
            }
852
        }
853
    }
854

    
855
    /* spectral extension coordinates */
856
    if (s->spx_in_use) {
857
        for (ch = 1; ch <= fbw_channels; ch++) {
858
            if (s->channel_uses_spx[ch]) {
859
                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
860
                    float spx_blend;
861
                    int bin, master_spx_coord;
862

    
863
                    s->first_spx_coords[ch] = 0;
864
                    spx_blend = get_bits(gbc, 5) * (1.0f/32);
865
                    master_spx_coord = get_bits(gbc, 2) * 3;
866

    
867
                    bin = s->spx_src_start_freq;
868
                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
869
                        int bandsize;
870
                        int spx_coord_exp, spx_coord_mant;
871
                        float nratio, sblend, nblend, spx_coord;
872

    
873
                        /* calculate blending factors */
874
                        bandsize = s->spx_band_sizes[bnd];
875
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
876
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
877
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
878
                        sblend = sqrtf(1.0f - nratio);
879
                        bin += bandsize;
880

    
881
                        /* decode spx coordinates */
882
                        spx_coord_exp  = get_bits(gbc, 4);
883
                        spx_coord_mant = get_bits(gbc, 2);
884
                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
885
                        else                     spx_coord_mant += 4;
886
                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
887
                        spx_coord = spx_coord_mant * (1.0f/(1<<23));
888

    
889
                        /* multiply noise and signal blending factors by spx coordinate */
890
                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
891
                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
892
                    }
893
                }
894
            } else {
895
                s->first_spx_coords[ch] = 1;
896
            }
897
        }
898
    }
899

    
900
    /* coupling strategy */
901
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
902
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
903
        if (!s->eac3)
904
            s->cpl_in_use[blk] = get_bits1(gbc);
905
        if (s->cpl_in_use[blk]) {
906
            /* coupling in use */
907
            int cpl_start_subband, cpl_end_subband;
908

    
909
            if (channel_mode < AC3_CHMODE_STEREO) {
910
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
911
                return -1;
912
            }
913

    
914
            /* check for enhanced coupling */
915
            if (s->eac3 && get_bits1(gbc)) {
916
                /* TODO: parse enhanced coupling strategy info */
917
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
918
                return -1;
919
            }
920

    
921
            /* determine which channels are coupled */
922
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
923
                s->channel_in_cpl[1] = 1;
924
                s->channel_in_cpl[2] = 1;
925
            } else {
926
                for (ch = 1; ch <= fbw_channels; ch++)
927
                    s->channel_in_cpl[ch] = get_bits1(gbc);
928
            }
929

    
930
            /* phase flags in use */
931
            if (channel_mode == AC3_CHMODE_STEREO)
932
                s->phase_flags_in_use = get_bits1(gbc);
933

    
934
            /* coupling frequency range */
935
            cpl_start_subband = get_bits(gbc, 4);
936
            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
937
                                              get_bits(gbc, 4) + 3;
938
            if (cpl_start_subband >= cpl_end_subband) {
939
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
940
                       cpl_start_subband, cpl_end_subband);
941
                return -1;
942
            }
943
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
944
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
945

    
946
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
947
                                  cpl_end_subband,
948
                                  ff_eac3_default_cpl_band_struct,
949
                                  &s->num_cpl_bands, s->cpl_band_sizes);
950
        } else {
951
            /* coupling not in use */
952
            for (ch = 1; ch <= fbw_channels; ch++) {
953
                s->channel_in_cpl[ch] = 0;
954
                s->first_cpl_coords[ch] = 1;
955
            }
956
            s->first_cpl_leak = s->eac3;
957
            s->phase_flags_in_use = 0;
958
        }
959
    } else if (!s->eac3) {
960
        if(!blk) {
961
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
962
            return -1;
963
        } else {
964
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
965
        }
966
    }
967
    cpl_in_use = s->cpl_in_use[blk];
968

    
969
    /* coupling coordinates */
970
    if (cpl_in_use) {
971
        int cpl_coords_exist = 0;
972

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

    
1006
    /* stereo rematrixing strategy and band structure */
1007
    if (channel_mode == AC3_CHMODE_STEREO) {
1008
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1009
            s->num_rematrixing_bands = 4;
1010
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1011
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1012
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1013
                s->num_rematrixing_bands--;
1014
            }
1015
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
1016
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1017
        } else if (!blk) {
1018
            av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
1019
            s->num_rematrixing_bands = 0;
1020
        }
1021
    }
1022

    
1023
    /* exponent strategies for each channel */
1024
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1025
        if (!s->eac3)
1026
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1027
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
1028
            bit_alloc_stages[ch] = 3;
1029
    }
1030

    
1031
    /* channel bandwidth */
1032
    for (ch = 1; ch <= fbw_channels; ch++) {
1033
        s->start_freq[ch] = 0;
1034
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1035
            int group_size;
1036
            int prev = s->end_freq[ch];
1037
            if (s->channel_in_cpl[ch])
1038
                s->end_freq[ch] = s->start_freq[CPL_CH];
1039
            else if (s->channel_uses_spx[ch])
1040
                s->end_freq[ch] = s->spx_src_start_freq;
1041
            else {
1042
                int bandwidth_code = get_bits(gbc, 6);
1043
                if (bandwidth_code > 60) {
1044
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1045
                    return -1;
1046
                }
1047
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1048
            }
1049
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1050
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
1051
            if(blk > 0 && s->end_freq[ch] != prev)
1052
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1053
        }
1054
    }
1055
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1056
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1057
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1058
    }
1059

    
1060
    /* decode exponents for each channel */
1061
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1062
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1063
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1064
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1065
                                 s->num_exp_groups[ch], s->dexps[ch][0],
1066
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1067
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1068
                return -1;
1069
            }
1070
            if(ch != CPL_CH && ch != s->lfe_ch)
1071
                skip_bits(gbc, 2); /* skip gainrng */
1072
        }
1073
    }
1074

    
1075
    /* bit allocation information */
1076
    if (s->bit_allocation_syntax) {
1077
        if (get_bits1(gbc)) {
1078
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1079
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1080
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1081
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1082
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1083
            for(ch=!cpl_in_use; ch<=s->channels; ch++)
1084
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1085
        } else if (!blk) {
1086
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1087
            return -1;
1088
        }
1089
    }
1090

    
1091
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1092
    if(!s->eac3 || !blk){
1093
        if(s->snr_offset_strategy && get_bits1(gbc)) {
1094
            int snr = 0;
1095
            int csnr;
1096
            csnr = (get_bits(gbc, 6) - 15) << 4;
1097
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1098
                /* snr offset */
1099
                if (ch == i || s->snr_offset_strategy == 2)
1100
                    snr = (csnr + get_bits(gbc, 4)) << 2;
1101
                /* run at least last bit allocation stage if snr offset changes */
1102
                if(blk && s->snr_offset[ch] != snr) {
1103
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1104
                }
1105
                s->snr_offset[ch] = snr;
1106

    
1107
                /* fast gain (normal AC-3 only) */
1108
                if (!s->eac3) {
1109
                    int prev = s->fast_gain[ch];
1110
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1111
                    /* run last 2 bit allocation stages if fast gain changes */
1112
                    if(blk && prev != s->fast_gain[ch])
1113
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1114
                }
1115
            }
1116
        } else if (!s->eac3 && !blk) {
1117
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1118
            return -1;
1119
        }
1120
    }
1121

    
1122
    /* fast gain (E-AC-3 only) */
1123
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1124
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1125
            int prev = s->fast_gain[ch];
1126
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1127
            /* run last 2 bit allocation stages if fast gain changes */
1128
            if(blk && prev != s->fast_gain[ch])
1129
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1130
        }
1131
    } else if (s->eac3 && !blk) {
1132
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1133
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1134
    }
1135

    
1136
    /* E-AC-3 to AC-3 converter SNR offset */
1137
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1138
        skip_bits(gbc, 10); // skip converter snr offset
1139
    }
1140

    
1141
    /* coupling leak information */
1142
    if (cpl_in_use) {
1143
        if (s->first_cpl_leak || get_bits1(gbc)) {
1144
            int fl = get_bits(gbc, 3);
1145
            int sl = get_bits(gbc, 3);
1146
            /* run last 2 bit allocation stages for coupling channel if
1147
               coupling leak changes */
1148
            if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1149
                       sl != s->bit_alloc_params.cpl_slow_leak)) {
1150
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1151
            }
1152
            s->bit_alloc_params.cpl_fast_leak = fl;
1153
            s->bit_alloc_params.cpl_slow_leak = sl;
1154
        } else if (!s->eac3 && !blk) {
1155
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1156
            return -1;
1157
        }
1158
        s->first_cpl_leak = 0;
1159
    }
1160

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

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

    
1224
    /* unused dummy data */
1225
    if (s->skip_syntax && get_bits1(gbc)) {
1226
        int skipl = get_bits(gbc, 9);
1227
        while(skipl--)
1228
            skip_bits(gbc, 8);
1229
    }
1230

    
1231
    /* unpack the transform coefficients
1232
       this also uncouples channels if coupling is in use. */
1233
    decode_transform_coeffs(s, blk);
1234

    
1235
    /* TODO: generate enhanced coupling coordinates and uncouple */
1236

    
1237
    /* recover coefficients if rematrixing is in use */
1238
    if(s->channel_mode == AC3_CHMODE_STEREO)
1239
        do_rematrixing(s);
1240

    
1241
    /* apply scaling to coefficients (headroom, dynrng) */
1242
    for(ch=1; ch<=s->channels; ch++) {
1243
        float gain = s->mul_bias / 4194304.0f;
1244
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1245
            gain *= s->dynamic_range[2-ch];
1246
        } else {
1247
            gain *= s->dynamic_range[0];
1248
        }
1249
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1250
    }
1251

    
1252
    /* apply spectral extension to high frequency bins */
1253
    if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1254
        ff_eac3_apply_spectral_extension(s);
1255
    }
1256

    
1257
    /* downmix and MDCT. order depends on whether block switching is used for
1258
       any channel in this block. this is because coefficients for the long
1259
       and short transforms cannot be mixed. */
1260
    downmix_output = s->channels != s->out_channels &&
1261
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1262
                     s->fbw_channels == s->out_channels);
1263
    if(different_transforms) {
1264
        /* the delay samples have already been downmixed, so we upmix the delay
1265
           samples in order to reconstruct all channels before downmixing. */
1266
        if(s->downmixed) {
1267
            s->downmixed = 0;
1268
            ac3_upmix_delay(s);
1269
        }
1270

    
1271
        do_imdct(s, s->channels);
1272

    
1273
        if(downmix_output) {
1274
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1275
        }
1276
    } else {
1277
        if(downmix_output) {
1278
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1279
        }
1280

    
1281
        if(downmix_output && !s->downmixed) {
1282
            s->downmixed = 1;
1283
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1284
        }
1285

    
1286
        do_imdct(s, s->out_channels);
1287
    }
1288

    
1289
    return 0;
1290
}
1291

    
1292
/**
1293
 * Decode a single AC-3 frame.
1294
 */
1295
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1296
                            AVPacket *avpkt)
1297
{
1298
    const uint8_t *buf = avpkt->data;
1299
    int buf_size = avpkt->size;
1300
    AC3DecodeContext *s = avctx->priv_data;
1301
    int16_t *out_samples = (int16_t *)data;
1302
    int blk, ch, err;
1303
    const uint8_t *channel_map;
1304
    const float *output[AC3_MAX_CHANNELS];
1305

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

    
1318
    /* parse the syncinfo */
1319
    *data_size = 0;
1320
    err = parse_frame_header(s);
1321

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

    
1364
    /* if frame is ok, set audio parameters */
1365
    if (!err) {
1366
        avctx->sample_rate = s->sample_rate;
1367
        avctx->bit_rate = s->bit_rate;
1368

    
1369
        /* channel config */
1370
        s->out_channels = s->channels;
1371
        s->output_mode = s->channel_mode;
1372
        if(s->lfe_on)
1373
            s->output_mode |= AC3_OUTPUT_LFEON;
1374
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1375
                avctx->request_channels < s->channels) {
1376
            s->out_channels = avctx->request_channels;
1377
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1378
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1379
        }
1380
        avctx->channels = s->out_channels;
1381
        avctx->channel_layout = s->channel_layout;
1382

    
1383
        /* set downmixing coefficients if needed */
1384
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1385
                s->fbw_channels == s->out_channels)) {
1386
            set_downmix_coeffs(s);
1387
        }
1388
    } else if (!s->out_channels) {
1389
        s->out_channels = avctx->channels;
1390
        if(s->out_channels < s->channels)
1391
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1392
    }
1393
    /* set audio service type based on bitstream mode for AC-3 */
1394
    avctx->audio_service_type = s->bitstream_mode;
1395
    if (s->bitstream_mode == 0x7 && s->channels > 1)
1396
        avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1397

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

    
1414
/**
1415
 * Uninitialize the AC-3 decoder.
1416
 */
1417
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1418
{
1419
    AC3DecodeContext *s = avctx->priv_data;
1420
    ff_mdct_end(&s->imdct_512);
1421
    ff_mdct_end(&s->imdct_256);
1422

    
1423
    av_freep(&s->input_buffer);
1424

    
1425
    return 0;
1426
}
1427

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

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