Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 4c64c8e9

History | View | Annotate | Download (52 KB)

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

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

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

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

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

    
49

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

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

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

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

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

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

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

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

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

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

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

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

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

    
172

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

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

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

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

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

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

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

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

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

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

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

    
250
    return 0;
251
}
252

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
716
    n_subbands = end_subband - start_subband;
717

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

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

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

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

    
769
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
770

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1290
    return 0;
1291
}
1292

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

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

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

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

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

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

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

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

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

    
1424
    av_freep(&s->input_buffer);
1425

    
1426
    return 0;
1427
}
1428

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

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