GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ac3dec.c Lines: 809 987 82.0 %
Date: 2019-11-22 03:34:36 Branches: 549 720 76.2 %

Line Branch Exec Source
1
/*
2
 * AC-3 Audio Decoder
3
 * This code was developed as part of Google Summer of Code 2006.
4
 * E-AC-3 support was added as part of Google Summer of Code 2007.
5
 *
6
 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
7
 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8
 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
9
 *
10
 * This file is part of FFmpeg.
11
 *
12
 * FFmpeg is free software; you can redistribute it and/or
13
 * modify it under the terms of the GNU Lesser General Public
14
 * License as published by the Free Software Foundation; either
15
 * version 2.1 of the License, or (at your option) any later version.
16
 *
17
 * FFmpeg is distributed in the hope that it will be useful,
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 * Lesser General Public License for more details.
21
 *
22
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with FFmpeg; if not, write to the Free Software
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25
 */
26
27
#include <stdio.h>
28
#include <stddef.h>
29
#include <math.h>
30
#include <string.h>
31
32
#include "libavutil/channel_layout.h"
33
#include "libavutil/crc.h"
34
#include "libavutil/downmix_info.h"
35
#include "libavutil/opt.h"
36
#include "bswapdsp.h"
37
#include "internal.h"
38
#include "aac_ac3_parser.h"
39
#include "ac3_parser_internal.h"
40
#include "ac3dec.h"
41
#include "ac3dec_data.h"
42
#include "kbdwin.h"
43
44
/**
45
 * table for ungrouping 3 values in 7 bits.
46
 * used for exponents and bap=2 mantissas
47
 */
48
static uint8_t ungroup_3_in_7_bits_tab[128][3];
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
#if (!USE_FIXED)
67
/** dynamic range table. converts codes to scale factors. */
68
static float dynamic_range_tab[256];
69
float ff_ac3_heavy_dynamic_range_tab[256];
70
#endif
71
72
/** Adjustments in dB gain */
73
static const float gain_levels[9] = {
74
    LEVEL_PLUS_3DB,
75
    LEVEL_PLUS_1POINT5DB,
76
    LEVEL_ONE,
77
    LEVEL_MINUS_1POINT5DB,
78
    LEVEL_MINUS_3DB,
79
    LEVEL_MINUS_4POINT5DB,
80
    LEVEL_MINUS_6DB,
81
    LEVEL_ZERO,
82
    LEVEL_MINUS_9DB
83
};
84
85
/** Adjustments in dB gain (LFE, +10 to -21 dB) */
86
static const float gain_levels_lfe[32] = {
87
    3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
88
    1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
89
    0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
90
    0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
91
    0.125892, 0.112201, 0.100000, 0.089125
92
};
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
39416
symmetric_dequant(int code, int levels)
116
{
117
39416
    return ((code - (levels >> 1)) * (1 << 24)) / levels;
118
}
119
120
/*
121
 * Initialize tables at runtime.
122
 */
123
52
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
6708
    for (i = 0; i < 128; i++) {
130
6656
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
131
6656
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
132
6656
        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
1716
    for (i = 0; i < 32; i++) {
138
        /* bap=1 mantissas */
139
1664
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
140
1664
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
141
1664
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
142
    }
143
6708
    for (i = 0; i < 128; i++) {
144
        /* bap=2 mantissas */
145
6656
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
146
6656
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
147
6656
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
148
149
        /* bap=4 mantissas */
150
6656
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
151
6656
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
152
    }
153
    /* generate ungrouped mantissa tables
154
       reference: Tables 7.21 and 7.23 */
155
416
    for (i = 0; i < 7; i++) {
156
        /* bap=3 mantissas */
157
364
        b3_mantissas[i] = symmetric_dequant(i, 7);
158
    }
159
832
    for (i = 0; i < 15; i++) {
160
        /* bap=5 mantissas */
161
780
        b5_mantissas[i] = symmetric_dequant(i, 15);
162
    }
163
164
#if (!USE_FIXED)
165
    /* generate dynamic range table
166
       reference: Section 7.7.1 Dynamic Range Control */
167
12336
    for (i = 0; i < 256; i++) {
168
12288
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
169
12288
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
170
    }
171
172
    /* generate compr dynamic range table
173
       reference: Section 7.7.2 Heavy Compression */
174
12336
    for (i = 0; i < 256; i++) {
175
12288
        int v = (i >> 4) - ((i >> 7) << 4) - 4;
176
12288
        ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
177
    }
178
#endif
179
52
}
180
181
/**
182
 * AVCodec initialization
183
 */
184
52
static av_cold int ac3_decode_init(AVCodecContext *avctx)
185
{
186
52
    AC3DecodeContext *s = avctx->priv_data;
187
    int i;
188
189
52
    s->avctx = avctx;
190
191
52
    ac3_tables_init();
192
52
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
193
52
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
194
52
    AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
195
52
    ff_bswapdsp_init(&s->bdsp);
196
197
#if (USE_FIXED)
198
4
    s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
199
#else
200
48
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
201
48
    ff_fmt_convert_init(&s->fmt_conv, avctx);
202
#endif
203
204
52
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
205
52
    av_lfg_init(&s->dith_state, 0);
206
207
    if (USE_FIXED)
208
4
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
209
    else
210
48
        avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
211
212
    /* allow downmixing to stereo or mono */
213
52
    if (avctx->channels > 1 &&
214
26
        avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
215
4
        avctx->channels = 1;
216
48
    else if (avctx->channels > 2 &&
217
10
             avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
218
3
        avctx->channels = 2;
219
52
    s->downmixed = 1;
220
221
416
    for (i = 0; i < AC3_MAX_CHANNELS; i++) {
222
364
        s->xcfptr[i] = s->transform_coeffs[i];
223
364
        s->dlyptr[i] = s->delay[i];
224
    }
225
226
52
    return 0;
227
}
228
229
/**
230
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
231
 * GetBitContext within AC3DecodeContext must point to
232
 * the start of the synchronized AC-3 bitstream.
233
 */
234
1222
static int ac3_parse_header(AC3DecodeContext *s)
235
{
236
1222
    GetBitContext *gbc = &s->gbc;
237
    int i;
238
239
    /* read the rest of the bsi. read twice for dual mono mode. */
240
1222
    i = !s->channel_mode;
241
    do {
242
1222
        s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
243
1222
        if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
244
            s->dialog_normalization[(!s->channel_mode)-i] = -31;
245
        }
246
1222
        if (s->target_level != 0) {
247
            s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
248
                (float)(s->target_level -
249
                s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
250
        }
251
1222
        if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
252
949
            s->heavy_dynamic_range[(!s->channel_mode)-i] =
253
949
                AC3_HEAVY_RANGE(get_bits(gbc, 8));
254
        }
255
1222
        if (get_bits1(gbc))
256
            skip_bits(gbc, 8); //skip language code
257
1222
        if (get_bits1(gbc))
258
542
            skip_bits(gbc, 7); //skip audio production information
259
1222
    } while (i--);
260
261
1222
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
262
263
    /* skip the timecodes or parse the Alternate Bit Stream Syntax */
264
1222
    if (s->bitstream_id != 6) {
265
1063
        if (get_bits1(gbc))
266
            skip_bits(gbc, 14); //skip timecode1
267
1063
        if (get_bits1(gbc))
268
            skip_bits(gbc, 14); //skip timecode2
269
    } else {
270
159
        if (get_bits1(gbc)) {
271
159
            s->preferred_downmix       = get_bits(gbc, 2);
272
159
            s->center_mix_level_ltrt   = get_bits(gbc, 3);
273
159
            s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
274
159
            s->center_mix_level        = get_bits(gbc, 3);
275
159
            s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
276
        }
277
159
        if (get_bits1(gbc)) {
278
159
            s->dolby_surround_ex_mode = get_bits(gbc, 2);
279
159
            s->dolby_headphone_mode   = get_bits(gbc, 2);
280
159
            skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
281
        }
282
    }
283
284
    /* skip additional bitstream info */
285
1222
    if (get_bits1(gbc)) {
286
        i = get_bits(gbc, 6);
287
        do {
288
            skip_bits(gbc, 8);
289
        } while (i--);
290
    }
291
292
1222
    return 0;
293
}
294
295
/**
296
 * Common function to parse AC-3 or E-AC-3 frame header
297
 */
298
2422
static int parse_frame_header(AC3DecodeContext *s)
299
{
300
    AC3HeaderInfo hdr;
301
    int err;
302
303
2422
    err = ff_ac3_parse_header(&s->gbc, &hdr);
304
2422
    if (err)
305
        return err;
306
307
    /* get decoding parameters from header info */
308
2422
    s->bit_alloc_params.sr_code     = hdr.sr_code;
309
2422
    s->bitstream_id                 = hdr.bitstream_id;
310
2422
    s->bitstream_mode               = hdr.bitstream_mode;
311
2422
    s->channel_mode                 = hdr.channel_mode;
312
2422
    s->lfe_on                       = hdr.lfe_on;
313
2422
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
314
2422
    s->sample_rate                  = hdr.sample_rate;
315
2422
    s->bit_rate                     = hdr.bit_rate;
316
2422
    s->channels                     = hdr.channels;
317
2422
    s->fbw_channels                 = s->channels - s->lfe_on;
318
2422
    s->lfe_ch                       = s->fbw_channels + 1;
319
2422
    s->frame_size                   = hdr.frame_size;
320
2422
    s->superframe_size             += hdr.frame_size;
321
2422
    s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
322
2422
    s->center_mix_level             = hdr.center_mix_level;
323
2422
    s->center_mix_level_ltrt        = 4; // -3.0dB
324
2422
    s->surround_mix_level           = hdr.surround_mix_level;
325
2422
    s->surround_mix_level_ltrt      = 4; // -3.0dB
326
2422
    s->lfe_mix_level_exists         = 0;
327
2422
    s->num_blocks                   = hdr.num_blocks;
328
2422
    s->frame_type                   = hdr.frame_type;
329
2422
    s->substreamid                  = hdr.substreamid;
330
2422
    s->dolby_surround_mode          = hdr.dolby_surround_mode;
331
2422
    s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
332
2422
    s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
333
334
2422
    if (s->lfe_on) {
335
585
        s->start_freq[s->lfe_ch]     = 0;
336
585
        s->end_freq[s->lfe_ch]       = 7;
337
585
        s->num_exp_groups[s->lfe_ch] = 2;
338
585
        s->channel_in_cpl[s->lfe_ch] = 0;
339
    }
340
341
2422
    if (s->bitstream_id <= 10) {
342
1222
        s->eac3                  = 0;
343
1222
        s->snr_offset_strategy   = 2;
344
1222
        s->block_switch_syntax   = 1;
345
1222
        s->dither_flag_syntax    = 1;
346
1222
        s->bit_allocation_syntax = 1;
347
1222
        s->fast_gain_syntax      = 0;
348
1222
        s->first_cpl_leak        = 0;
349
1222
        s->dba_syntax            = 1;
350
1222
        s->skip_syntax           = 1;
351
1222
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
352
1222
        return ac3_parse_header(s);
353
    } else if (CONFIG_EAC3_DECODER) {
354
1200
        s->eac3 = 1;
355
1200
        return ff_eac3_parse_header(s);
356
    } else {
357
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
358
        return AVERROR(ENOSYS);
359
    }
360
}
361
362
/**
363
 * Set stereo downmixing coefficients based on frame header info.
364
 * reference: Section 7.8.2 Downmixing Into Two Channels
365
 */
366
410
static int set_downmix_coeffs(AC3DecodeContext *s)
367
{
368
    int i;
369
410
    float cmix = gain_levels[s->  center_mix_level];
370
410
    float smix = gain_levels[s->surround_mix_level];
371
    float norm0, norm1;
372
    float downmix_coeffs[2][AC3_MAX_CHANNELS];
373
374
410
    if (!s->downmix_coeffs[0]) {
375
7
        s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
376
                                               sizeof(**s->downmix_coeffs));
377
7
        if (!s->downmix_coeffs[0])
378
            return AVERROR(ENOMEM);
379
7
        s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
380
    }
381
382
2274
    for (i = 0; i < s->fbw_channels; i++) {
383
1864
        downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
384
1864
        downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
385
    }
386

410
    if (s->channel_mode > 1 && s->channel_mode & 1) {
387
410
        downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
388
    }
389

410
    if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
390
186
        int nf = s->channel_mode - 2;
391
186
        downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
392
    }
393

410
    if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
394
224
        int nf = s->channel_mode - 4;
395
224
        downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
396
    }
397
398
    /* renormalize */
399
410
    norm0 = norm1 = 0.0;
400
2274
    for (i = 0; i < s->fbw_channels; i++) {
401
1864
        norm0 += downmix_coeffs[0][i];
402
1864
        norm1 += downmix_coeffs[1][i];
403
    }
404
410
    norm0 = 1.0f / norm0;
405
410
    norm1 = 1.0f / norm1;
406
2274
    for (i = 0; i < s->fbw_channels; i++) {
407
1864
        downmix_coeffs[0][i] *= norm0;
408
1864
        downmix_coeffs[1][i] *= norm1;
409
    }
410
411
410
    if (s->output_mode == AC3_CHMODE_MONO) {
412
1292
        for (i = 0; i < s->fbw_channels; i++)
413
1056
            downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
414
1056
                                    downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
415
    }
416
2274
    for (i = 0; i < s->fbw_channels; i++) {
417
1864
        s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
418
1864
        s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
419
    }
420
421
410
    return 0;
422
}
423
424
/**
425
 * Decode the grouped exponents according to exponent strategy.
426
 * reference: Section 7.1.3 Exponent Decoding
427
 */
428
13377
static int decode_exponents(AC3DecodeContext *s,
429
                            GetBitContext *gbc, int exp_strategy, int ngrps,
430
                            uint8_t absexp, int8_t *dexps)
431
{
432
    int i, j, grp, group_size;
433
    int dexp[256];
434
    int expacc, prevexp;
435
436
    /* unpack groups */
437
13377
    group_size = exp_strategy + (exp_strategy == EXP_D45);
438
478758
    for (grp = 0, i = 0; grp < ngrps; grp++) {
439
465381
        expacc = get_bits(gbc, 7);
440
465381
        if (expacc >= 125) {
441
            av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
442
            return AVERROR_INVALIDDATA;
443
        }
444
465381
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
445
465381
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
446
465381
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
447
    }
448
449
    /* convert to absolute exps and expand groups */
450
13377
    prevexp = absexp;
451
1409520
    for (i = 0, j = 0; i < ngrps * 3; i++) {
452
1396143
        prevexp += dexp[i] - 2;
453
1396143
        if (prevexp > 24U) {
454
            av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
455
            return AVERROR_INVALIDDATA;
456
        }
457

1396143
        switch (group_size) {
458
103407
        case 4: dexps[j++] = prevexp;
459
103407
                dexps[j++] = prevexp;
460
269445
        case 2: dexps[j++] = prevexp;
461
1396143
        case 1: dexps[j++] = prevexp;
462
        }
463
    }
464
13377
    return 0;
465
}
466
467
/**
468
 * Generate transform coefficients for each coupled channel in the coupling
469
 * range using the coupling coefficients and coupling coordinates.
470
 * reference: Section 7.4.3 Coupling Coordinate Format
471
 */
472
7274
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
473
{
474
    int bin, band, ch;
475
476
7274
    bin = s->start_freq[CPL_CH];
477
33070
    for (band = 0; band < s->num_cpl_bands; band++) {
478
25796
        int band_start = bin;
479
25796
        int band_end = bin + s->cpl_band_sizes[band];
480
87288
        for (ch = 1; ch <= s->fbw_channels; ch++) {
481
61492
            if (s->channel_in_cpl[ch]) {
482
61492
                int cpl_coord = s->cpl_coords[ch][band] << 5;
483
1456204
                for (bin = band_start; bin < band_end; bin++) {
484
1394712
                    s->fixed_coeffs[ch][bin] =
485
1394712
                        MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
486
                }
487

61492
                if (ch == 2 && s->phase_flags[band]) {
488
                    for (bin = band_start; bin < band_end; bin++)
489
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
490
                }
491
            }
492
        }
493
25796
        bin = band_end;
494
    }
495
7274
}
496
497
/**
498
 * Grouped mantissas for 3-level 5-level and 11-level quantization
499
 */
500
typedef struct mant_groups {
501
    int b1_mant[2];
502
    int b2_mant[2];
503
    int b4_mant;
504
    int b1;
505
    int b2;
506
    int b4;
507
} mant_groups;
508
509
/**
510
 * Decode the transform coefficients for a particular channel
511
 * reference: Section 7.3 Quantization and Decoding of Mantissas
512
 */
513
47270
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
514
{
515
47270
    int start_freq = s->start_freq[ch_index];
516
47270
    int end_freq   = s->end_freq[ch_index];
517
47270
    uint8_t *baps  = s->bap[ch_index];
518
47270
    int8_t *exps   = s->dexps[ch_index];
519
47270
    int32_t *coeffs = s->fixed_coeffs[ch_index];
520

47270
    int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
521
47270
    GetBitContext *gbc = &s->gbc;
522
    int freq;
523
524
6668546
    for (freq = start_freq; freq < end_freq; freq++) {
525
6621276
        int bap = baps[freq];
526
        int mantissa;
527

6621276
        switch (bap) {
528
2028799
        case 0:
529
            /* random noise with approximate range of -0.707 to 0.707 */
530
2028799
            if (dither)
531
2024548
                mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
532
            else
533
4251
                mantissa = 0;
534
2028799
            break;
535
1367766
        case 1:
536
1367766
            if (m->b1) {
537
908028
                m->b1--;
538
908028
                mantissa = m->b1_mant[m->b1];
539
            } else {
540
459738
                int bits      = get_bits(gbc, 5);
541
459738
                mantissa      = b1_mantissas[bits][0];
542
459738
                m->b1_mant[1] = b1_mantissas[bits][1];
543
459738
                m->b1_mant[0] = b1_mantissas[bits][2];
544
459738
                m->b1         = 2;
545
            }
546
1367766
            break;
547
635898
        case 2:
548
635898
            if (m->b2) {
549
420313
                m->b2--;
550
420313
                mantissa = m->b2_mant[m->b2];
551
            } else {
552
215585
                int bits      = get_bits(gbc, 7);
553
215585
                mantissa      = b2_mantissas[bits][0];
554
215585
                m->b2_mant[1] = b2_mantissas[bits][1];
555
215585
                m->b2_mant[0] = b2_mantissas[bits][2];
556
215585
                m->b2         = 2;
557
            }
558
635898
            break;
559
735620
        case 3:
560
735620
            mantissa = b3_mantissas[get_bits(gbc, 3)];
561
735620
            break;
562
478310
        case 4:
563
478310
            if (m->b4) {
564
236175
                m->b4 = 0;
565
236175
                mantissa = m->b4_mant;
566
            } else {
567
242135
                int bits   = get_bits(gbc, 7);
568
242135
                mantissa   = b4_mantissas[bits][0];
569
242135
                m->b4_mant = b4_mantissas[bits][1];
570
242135
                m->b4      = 1;
571
            }
572
478310
            break;
573
394678
        case 5:
574
394678
            mantissa = b5_mantissas[get_bits(gbc, 4)];
575
394678
            break;
576
980205
        default: /* 6 to 15 */
577
            /* Shift mantissa and sign-extend it. */
578
980205
            if (bap > 15) {
579
                av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
580
                bap = 15;
581
            }
582
980205
            mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
583
980205
            break;
584
        }
585
6621276
        coeffs[freq] = mantissa >> exps[freq];
586
    }
587
47270
}
588
589
/**
590
 * Remove random dithering from coupling range coefficients with zero-bit
591
 * mantissas for coupled channels which do not use dithering.
592
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
593
 */
594
14000
static void remove_dithering(AC3DecodeContext *s) {
595
    int ch, i;
596
597
55854
    for (ch = 1; ch <= s->fbw_channels; ch++) {
598

41854
        if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
599
            for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
600
                if (!s->bap[CPL_CH][i])
601
                    s->fixed_coeffs[ch][i] = 0;
602
            }
603
        }
604
    }
605
14000
}
606
607
52118
static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
608
                                              int ch, mant_groups *m)
609
{
610
52118
    if (!s->channel_uses_aht[ch]) {
611
47270
        ac3_decode_transform_coeffs_ch(s, ch, m);
612
    } else {
613
        /* if AHT is used, mantissas for all blocks are encoded in the first
614
           block of the frame. */
615
        int bin;
616
4848
        if (CONFIG_EAC3_DECODER && !blk)
617
808
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
618
597684
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
619
592836
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
620
        }
621
    }
622
52118
}
623
624
/**
625
 * Decode the transform coefficients.
626
 */
627
14000
static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
628
{
629
    int ch, end;
630
14000
    int got_cplchan = 0;
631
    mant_groups m;
632
633
14000
    m.b1 = m.b2 = m.b4 = 0;
634
635
58844
    for (ch = 1; ch <= s->channels; ch++) {
636
        /* transform coefficients for full-bandwidth channel */
637
44844
        decode_transform_coeffs_ch(s, blk, ch, &m);
638
        /* transform coefficients for coupling channel come right after the
639
           coefficients for the first coupled channel*/
640
44844
        if (s->channel_in_cpl[ch])  {
641
19498
            if (!got_cplchan) {
642
7274
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
643
7274
                calc_transform_coeffs_cpl(s);
644
7274
                got_cplchan = 1;
645
            }
646
19498
            end = s->end_freq[CPL_CH];
647
        } else {
648
25346
            end = s->end_freq[ch];
649
        }
650
        do
651
3420096
            s->fixed_coeffs[ch][end] = 0;
652
3420096
        while (++end < 256);
653
    }
654
655
    /* zero the dithered coefficients for appropriate channels */
656
14000
    remove_dithering(s);
657
14000
}
658
659
/**
660
 * Stereo rematrixing.
661
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
662
 */
663
8568
static void do_rematrixing(AC3DecodeContext *s)
664
{
665
    int bnd, i;
666
    int end, bndend;
667
668
8568
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
669
670
42840
    for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
671
34272
        if (s->rematrixing_flags[bnd]) {
672
23228
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
673
635252
            for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
674
612024
                int tmp0 = s->fixed_coeffs[1][i];
675
612024
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
676
612024
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
677
            }
678
        }
679
    }
680
8568
}
681
682
/**
683
 * Inverse MDCT Transform.
684
 * Convert frequency domain coefficients to time-domain audio samples.
685
 * reference: Section 7.9.4 Transformation Equations
686
 */
687
14000
static inline void do_imdct(AC3DecodeContext *s, int channels, int offset)
688
{
689
    int ch;
690
691
49936
    for (ch = 1; ch <= channels; ch++) {
692
35936
        if (s->block_switch[ch]) {
693
            int i;
694
6
            FFTSample *x = s->tmp_output + 128;
695
774
            for (i = 0; i < 128; i++)
696
768
                x[i] = s->transform_coeffs[ch][2 * i];
697
6
            s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
698
#if USE_FIXED
699
2
            s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
700
2
                                       s->tmp_output, s->window, 128, 8);
701
#else
702
4
            s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
703
4
                                       s->tmp_output, s->window, 128);
704
#endif
705
774
            for (i = 0; i < 128; i++)
706
768
                x[i] = s->transform_coeffs[ch][2 * i + 1];
707
6
            s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
708
        } else {
709
35930
            s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
710
#if USE_FIXED
711
2923
            s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
712
2923
                                       s->tmp_output, s->window, 128, 8);
713
#else
714
33007
            s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
715
33007
                                       s->tmp_output, s->window, 128);
716
#endif
717
35930
            memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample));
718
        }
719
    }
720
14000
}
721
722
/**
723
 * Upmix delay samples from stereo to original channel layout.
724
 */
725
6
static void ac3_upmix_delay(AC3DecodeContext *s)
726
{
727
6
    int channel_data_size = sizeof(s->delay[0]);
728

6
    switch (s->channel_mode) {
729
2
    case AC3_CHMODE_DUALMONO:
730
    case AC3_CHMODE_STEREO:
731
        /* upmix mono to stereo */
732
2
        memcpy(s->delay[1], s->delay[0], channel_data_size);
733
2
        break;
734
    case AC3_CHMODE_2F2R:
735
        memset(s->delay[3], 0, channel_data_size);
736
    case AC3_CHMODE_2F1R:
737
        memset(s->delay[2], 0, channel_data_size);
738
        break;
739
    case AC3_CHMODE_3F2R:
740
        memset(s->delay[4], 0, channel_data_size);
741
4
    case AC3_CHMODE_3F1R:
742
4
        memset(s->delay[3], 0, channel_data_size);
743
4
    case AC3_CHMODE_3F:
744
4
        memcpy(s->delay[2], s->delay[1], channel_data_size);
745
4
        memset(s->delay[1], 0, channel_data_size);
746
4
        break;
747
    }
748
6
}
749
750
/**
751
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
752
 * The band structure defines how many subbands are in each band.  For each
753
 * subband in the range, 1 means it is combined with the previous band, and 0
754
 * means that it starts a new band.
755
 *
756
 * @param[in] gbc bit reader context
757
 * @param[in] blk block number
758
 * @param[in] eac3 flag to indicate E-AC-3
759
 * @param[in] ecpl flag to indicate enhanced coupling
760
 * @param[in] start_subband subband number for start of range
761
 * @param[in] end_subband subband number for end of range
762
 * @param[in] default_band_struct default band structure table
763
 * @param[out] num_bands number of bands (optionally NULL)
764
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
765
 * @param[in,out] band_struct current band structure
766
 */
767
1751
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
768
                                  int ecpl, int start_subband, int end_subband,
769
                                  const uint8_t *default_band_struct,
770
                                  int *num_bands, uint8_t *band_sizes,
771
                                  uint8_t *band_struct, int band_struct_size)
772
{
773
1751
    int subbnd, bnd, n_subbands, n_bands=0;
774
    uint8_t bnd_sz[22];
775
776
1751
    n_subbands = end_subband - start_subband;
777
778
1751
    if (!blk)
779
1751
        memcpy(band_struct, default_band_struct, band_struct_size);
780
781
1751
    av_assert0(band_struct_size >= start_subband + n_subbands);
782
783
1751
    band_struct += start_subband + 1;
784
785
    /* decode band structure from bitstream or use default */
786

1751
    if (!eac3 || get_bits1(gbc)) {
787
6348
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
788
5002
            band_struct[subbnd] = get_bits1(gbc);
789
        }
790
    }
791
792
    /* calculate number of bands and band sizes based on band structure.
793
       note that the first 4 subbands in enhanced coupling span only 6 bins
794
       instead of 12. */
795

1751
    if (num_bands || band_sizes ) {
796
1751
        n_bands = n_subbands;
797
1751
        bnd_sz[0] = ecpl ? 6 : 12;
798
8897
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
799

7146
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
800
7146
            if (band_struct[subbnd - 1]) {
801
3375
                n_bands--;
802
3375
                bnd_sz[bnd] += subbnd_size;
803
            } else {
804
3771
                bnd_sz[++bnd] = subbnd_size;
805
            }
806
        }
807
    }
808
809
    /* set optional output params */
810
1751
    if (num_bands)
811
1751
        *num_bands = n_bands;
812
1751
    if (band_sizes)
813
1751
        memcpy(band_sizes, bnd_sz, n_bands);
814
1751
}
815
816
538
static inline int spx_strategy(AC3DecodeContext *s, int blk)
817
{
818
538
    GetBitContext *bc = &s->gbc;
819
538
    int fbw_channels = s->fbw_channels;
820
    int dst_start_freq, dst_end_freq, src_start_freq,
821
        start_subband, end_subband, ch;
822
823
    /* determine which channels use spx */
824
538
    if (s->channel_mode == AC3_CHMODE_MONO) {
825
        s->channel_uses_spx[1] = 1;
826
    } else {
827
1758
        for (ch = 1; ch <= fbw_channels; ch++)
828
1220
            s->channel_uses_spx[ch] = get_bits1(bc);
829
    }
830
831
    /* get the frequency bins of the spx copy region and the spx start
832
       and end subbands */
833
538
    dst_start_freq = get_bits(bc, 2);
834
538
    start_subband  = get_bits(bc, 3) + 2;
835
538
    if (start_subband > 7)
836
490
        start_subband += start_subband - 7;
837
538
    end_subband    = get_bits(bc, 3) + 5;
838
#if USE_FIXED
839
    s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
840
#endif
841
538
    if (end_subband   > 7)
842
538
        end_subband   += end_subband   - 7;
843
538
    dst_start_freq = dst_start_freq * 12 + 25;
844
538
    src_start_freq = start_subband  * 12 + 25;
845
538
    dst_end_freq   = end_subband    * 12 + 25;
846
847
    /* check validity of spx ranges */
848
538
    if (start_subband >= end_subband) {
849
        av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
850
               "range (%d >= %d)\n", start_subband, end_subband);
851
        return AVERROR_INVALIDDATA;
852
    }
853
538
    if (dst_start_freq >= src_start_freq) {
854
        av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
855
               "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
856
        return AVERROR_INVALIDDATA;
857
    }
858
859
538
    s->spx_dst_start_freq = dst_start_freq;
860
538
    s->spx_src_start_freq = src_start_freq;
861
    if (!USE_FIXED)
862
538
        s->spx_dst_end_freq   = dst_end_freq;
863
864
538
    decode_band_structure(bc, blk, s->eac3, 0,
865
                          start_subband, end_subband,
866
                          ff_eac3_default_spx_band_struct,
867
                          &s->num_spx_bands,
868
538
                          s->spx_band_sizes,
869
538
                          s->spx_band_struct, sizeof(s->spx_band_struct));
870
538
    return 0;
871
}
872
873
3228
static inline void spx_coordinates(AC3DecodeContext *s)
874
{
875
3228
    GetBitContext *bc = &s->gbc;
876
3228
    int fbw_channels = s->fbw_channels;
877
    int ch, bnd;
878
879
10548
    for (ch = 1; ch <= fbw_channels; ch++) {
880
7320
        if (s->channel_uses_spx[ch]) {
881

7320
            if (s->first_spx_coords[ch] || get_bits1(bc)) {
882
                INTFLOAT spx_blend;
883
                int bin, master_spx_coord;
884
885
1959
                s->first_spx_coords[ch] = 0;
886
1959
                spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
887
1959
                master_spx_coord = get_bits(bc, 2) * 3;
888
889
1959
                bin = s->spx_src_start_freq;
890
6876
                for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
891
4917
                    int bandsize = s->spx_band_sizes[bnd];
892
                    int spx_coord_exp, spx_coord_mant;
893
                    INTFLOAT nratio, sblend, nblend;
894
#if USE_FIXED
895
                    /* calculate blending factors */
896
                    int64_t accu = ((bin << 23) + (bandsize << 22))
897
                                 * (int64_t)s->spx_dst_end_freq;
898
                    nratio = (int)(accu >> 32);
899
                    nratio -= spx_blend << 18;
900
901
                    if (nratio < 0) {
902
                        nblend = 0;
903
                        sblend = 0x800000;
904
                    } else if (nratio > 0x7fffff) {
905
                        nblend = 14529495; // sqrt(3) in FP.23
906
                        sblend = 0;
907
                    } else {
908
                        nblend = fixed_sqrt(nratio, 23);
909
                        accu = (int64_t)nblend * 1859775393;
910
                        nblend = (int)((accu + (1<<29)) >> 30);
911
                        sblend = fixed_sqrt(0x800000 - nratio, 23);
912
                    }
913
#else
914
                    float spx_coord;
915
916
                    /* calculate blending factors */
917
4917
                    nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
918
4917
                    nratio = av_clipf(nratio, 0.0f, 1.0f);
919
4917
                    nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
920
                                                   // to give unity variance
921
4917
                    sblend = sqrtf(1.0f - nratio);
922
#endif
923
4917
                    bin += bandsize;
924
925
                    /* decode spx coordinates */
926
4917
                    spx_coord_exp  = get_bits(bc, 4);
927
4917
                    spx_coord_mant = get_bits(bc, 2);
928
4917
                    if (spx_coord_exp == 15) spx_coord_mant <<= 1;
929
4199
                    else                     spx_coord_mant += 4;
930
4917
                    spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
931
932
                    /* multiply noise and signal blending factors by spx coordinate */
933
#if USE_FIXED
934
                    accu = (int64_t)nblend * spx_coord_mant;
935
                    s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
936
                    accu = (int64_t)sblend * spx_coord_mant;
937
                    s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
938
#else
939
4917
                    spx_coord = spx_coord_mant * (1.0f / (1 << 23));
940
4917
                    s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
941
4917
                    s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
942
#endif
943
                }
944
            }
945
        } else {
946
            s->first_spx_coords[ch] = 1;
947
        }
948
    }
949
3228
}
950
951
2417
static inline int coupling_strategy(AC3DecodeContext *s, int blk,
952
                                    uint8_t *bit_alloc_stages)
953
{
954
2417
    GetBitContext *bc = &s->gbc;
955
2417
    int fbw_channels = s->fbw_channels;
956
2417
    int channel_mode = s->channel_mode;
957
    int ch;
958
959
2417
    memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
960
2417
    if (!s->eac3)
961
1217
        s->cpl_in_use[blk] = get_bits1(bc);
962
2417
    if (s->cpl_in_use[blk]) {
963
        /* coupling in use */
964
        int cpl_start_subband, cpl_end_subband;
965
966
1213
        if (channel_mode < AC3_CHMODE_STEREO) {
967
            av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
968
            return AVERROR_INVALIDDATA;
969
        }
970
971
        /* check for enhanced coupling */
972

1213
        if (s->eac3 && get_bits1(bc)) {
973
            /* TODO: parse enhanced coupling strategy info */
974
            avpriv_request_sample(s->avctx, "Enhanced coupling");
975
            return AVERROR_PATCHWELCOME;
976
        }
977
978
        /* determine which channels are coupled */
979

1213
        if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
980
405
            s->channel_in_cpl[1] = 1;
981
405
            s->channel_in_cpl[2] = 1;
982
        } else {
983
3249
            for (ch = 1; ch <= fbw_channels; ch++)
984
2441
                s->channel_in_cpl[ch] = get_bits1(bc);
985
        }
986
987
        /* phase flags in use */
988
1213
        if (channel_mode == AC3_CHMODE_STEREO)
989
938
            s->phase_flags_in_use = get_bits1(bc);
990
991
        /* coupling frequency range */
992
1213
        cpl_start_subband = get_bits(bc, 4);
993
1213
        cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
994
1213
                                          get_bits(bc, 4) + 3;
995
1213
        if (cpl_start_subband >= cpl_end_subband) {
996
            av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
997
                   cpl_start_subband, cpl_end_subband);
998
            return AVERROR_INVALIDDATA;
999
        }
1000
1213
        s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1001
1213
        s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1002
1003
1213
        decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1004
                              cpl_end_subband,
1005
                              ff_eac3_default_cpl_band_struct,
1006
1213
                              &s->num_cpl_bands, s->cpl_band_sizes,
1007
1213
                              s->cpl_band_struct, sizeof(s->cpl_band_struct));
1008
    } else {
1009
        /* coupling not in use */
1010
5341
        for (ch = 1; ch <= fbw_channels; ch++) {
1011
4137
            s->channel_in_cpl[ch] = 0;
1012
4137
            s->first_cpl_coords[ch] = 1;
1013
        }
1014
1204
        s->first_cpl_leak = s->eac3;
1015
1204
        s->phase_flags_in_use = 0;
1016
    }
1017
1018
2417
    return 0;
1019
}
1020
1021
7274
static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1022
{
1023
7274
    GetBitContext *bc = &s->gbc;
1024
7274
    int fbw_channels = s->fbw_channels;
1025
    int ch, bnd;
1026
7274
    int cpl_coords_exist = 0;
1027
1028
26772
    for (ch = 1; ch <= fbw_channels; ch++) {
1029
19498
        if (s->channel_in_cpl[ch]) {
1030

25254
            if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1031
                int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1032
5756
                s->first_cpl_coords[ch] = 0;
1033
5756
                cpl_coords_exist = 1;
1034
5756
                master_cpl_coord = 3 * get_bits(bc, 2);
1035
21080
                for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1036
15324
                    cpl_coord_exp  = get_bits(bc, 4);
1037
15324
                    cpl_coord_mant = get_bits(bc, 4);
1038
15324
                    if (cpl_coord_exp == 15)
1039
2510
                        s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1040
                    else
1041
12814
                        s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1042
15324
                    s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1043
                }
1044
13742
            } else if (!blk) {
1045
                av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1046
                       "be present in block 0\n");
1047
                return AVERROR_INVALIDDATA;
1048
            }
1049
        } else {
1050
            /* channel not in coupling */
1051
            s->first_cpl_coords[ch] = 1;
1052
        }
1053
    }
1054
    /* phase flags */
1055

7274
    if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1056
4830
        for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1057
3864
            s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1058
        }
1059
    }
1060
1061
7274
    return 0;
1062
}
1063
1064
/**
1065
 * Decode a single audio block from the AC-3 bitstream.
1066
 */
1067
14000
static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1068
{
1069
14000
    int fbw_channels = s->fbw_channels;
1070
14000
    int channel_mode = s->channel_mode;
1071
    int i, bnd, seg, ch, ret;
1072
    int different_transforms;
1073
    int downmix_output;
1074
    int cpl_in_use;
1075
14000
    GetBitContext *gbc = &s->gbc;
1076
14000
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1077
1078
    /* block switch flags */
1079
14000
    different_transforms = 0;
1080
14000
    if (s->block_switch_syntax) {
1081
32658
        for (ch = 1; ch <= fbw_channels; ch++) {
1082
25368
            s->block_switch[ch] = get_bits1(gbc);
1083

25368
            if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1084
6
                different_transforms = 1;
1085
        }
1086
    }
1087
1088
    /* dithering flags */
1089
14000
    if (s->dither_flag_syntax) {
1090
32658
        for (ch = 1; ch <= fbw_channels; ch++) {
1091
25368
            s->dither_flag[ch] = get_bits1(gbc);
1092
        }
1093
    }
1094
1095
    /* dynamic range */
1096
14000
    i = !s->channel_mode;
1097
    do {
1098
14000
        if (get_bits1(gbc)) {
1099
            /* Allow asymmetric application of DRC when drc_scale > 1.
1100
               Amplification of quiet sounds is enhanced */
1101
2723
            int range_bits = get_bits(gbc, 8);
1102
2723
            INTFLOAT range = AC3_RANGE(range_bits);
1103

2723
            if (range_bits <= 127 || s->drc_scale <= 1.0)
1104
2625
                s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1105
            else
1106
98
                s->dynamic_range[i] = range;
1107
11277
        } else if (blk == 0) {
1108
703
            s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1109
        }
1110
14000
    } while (i--);
1111
1112
    /* spectral extension strategy */
1113

14000
    if (s->eac3 && (!blk || get_bits1(gbc))) {
1114
1200
        s->spx_in_use = get_bits1(gbc);
1115
1200
        if (s->spx_in_use) {
1116
538
            if ((ret = spx_strategy(s, blk)) < 0)
1117
                return ret;
1118
        }
1119
    }
1120

14000
    if (!s->eac3 || !s->spx_in_use) {
1121
10772
        s->spx_in_use = 0;
1122
45306
        for (ch = 1; ch <= fbw_channels; ch++) {
1123
34534
            s->channel_uses_spx[ch] = 0;
1124
34534
            s->first_spx_coords[ch] = 1;
1125
        }
1126
    }
1127
1128
    /* spectral extension coordinates */
1129
14000
    if (s->spx_in_use)
1130
3228
        spx_coordinates(s);
1131
1132
    /* coupling strategy */
1133

14000
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1134
2417
        if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1135
            return ret;
1136
11583
    } else if (!s->eac3) {
1137
6073
        if (!blk) {
1138
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1139
                   "be present in block 0\n");
1140
            return AVERROR_INVALIDDATA;
1141
        } else {
1142
6073
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1143
        }
1144
    }
1145
14000
    cpl_in_use = s->cpl_in_use[blk];
1146
1147
    /* coupling coordinates */
1148
14000
    if (cpl_in_use) {
1149
7274
        if ((ret = coupling_coordinates(s, blk)) < 0)
1150
            return ret;
1151
    }
1152
1153
    /* stereo rematrixing strategy and band structure */
1154
14000
    if (channel_mode == AC3_CHMODE_STEREO) {
1155

8568
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1156
2836
            s->num_rematrixing_bands = 4;
1157

2836
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1158
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1159

2836
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1160
                s->num_rematrixing_bands--;
1161
            }
1162
14180
            for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1163
11344
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1164
5732
        } else if (!blk) {
1165
            av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1166
                   "new rematrixing strategy not present in block 0\n");
1167
            s->num_rematrixing_bands = 0;
1168
        }
1169
    }
1170
1171
    /* exponent strategies for each channel */
1172
66118
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1173
52118
        if (!s->eac3)
1174
32816
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1175
52118
        if (s->exp_strategy[blk][ch] != EXP_REUSE)
1176
13377
            bit_alloc_stages[ch] = 3;
1177
    }
1178
1179
    /* channel bandwidth */
1180
55854
    for (ch = 1; ch <= fbw_channels; ch++) {
1181
41854
        s->start_freq[ch] = 0;
1182
41854
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1183
            int group_size;
1184
10377
            int prev = s->end_freq[ch];
1185
10377
            if (s->channel_in_cpl[ch])
1186
4078
                s->end_freq[ch] = s->start_freq[CPL_CH];
1187
6299
            else if (s->channel_uses_spx[ch])
1188
1959
                s->end_freq[ch] = s->spx_src_start_freq;
1189
            else {
1190
4340
                int bandwidth_code = get_bits(gbc, 6);
1191
4340
                if (bandwidth_code > 60) {
1192
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1193
                    return AVERROR_INVALIDDATA;
1194
                }
1195
4340
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1196
            }
1197
10377
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1198
10377
            s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1199

10377
            if (blk > 0 && s->end_freq[ch] != prev)
1200
4
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1201
        }
1202
    }
1203

14000
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1204
2393
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1205
2393
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1206
    }
1207
1208
    /* decode exponents for each channel */
1209
66118
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1210
52118
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1211
13377
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1212
13377
            if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1213
13377
                                 s->num_exp_groups[ch], s->dexps[ch][0],
1214
13377
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1215
                return AVERROR_INVALIDDATA;
1216
            }
1217

13377
            if (ch != CPL_CH && ch != s->lfe_ch)
1218
10377
                skip_bits(gbc, 2); /* skip gainrng */
1219
        }
1220
    }
1221
1222
    /* bit allocation information */
1223
14000
    if (s->bit_allocation_syntax) {
1224
8516
        if (get_bits1(gbc)) {
1225
1535
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1226
1535
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1227
1535
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1228
1535
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1229
1535
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1230
8428
            for (ch = !cpl_in_use; ch <= s->channels; ch++)
1231
6893
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1232
6981
        } else if (!blk) {
1233
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1234
                   "be present in block 0\n");
1235
            return AVERROR_INVALIDDATA;
1236
        }
1237
    }
1238
1239
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1240

14000
    if (!s->eac3 || !blk) {
1241

9705
        if (s->snr_offset_strategy && get_bits1(gbc)) {
1242
1215
            int snr = 0;
1243
            int csnr;
1244
1215
            csnr = (get_bits(gbc, 6) - 15) << 4;
1245
6685
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1246
                /* snr offset */
1247

5470
                if (ch == i || s->snr_offset_strategy == 2)
1248
5470
                    snr = (csnr + get_bits(gbc, 4)) << 2;
1249
                /* run at least last bit allocation stage if snr offset changes */
1250

5470
                if (blk && s->snr_offset[ch] != snr) {
1251
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1252
                }
1253
5470
                s->snr_offset[ch] = snr;
1254
1255
                /* fast gain (normal AC-3 only) */
1256
5470
                if (!s->eac3) {
1257
5470
                    int prev = s->fast_gain[ch];
1258
5470
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1259
                    /* run last 2 bit allocation stages if fast gain changes */
1260

5470
                    if (blk && prev != s->fast_gain[ch])
1261
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1262
                }
1263
            }
1264

7275
        } else if (!s->eac3 && !blk) {
1265
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1266
            return AVERROR_INVALIDDATA;
1267
        }
1268
    }
1269
1270
    /* fast gain (E-AC-3 only) */
1271

14000
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1272
4770
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1273
3816
            int prev = s->fast_gain[ch];
1274
3816
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1275
            /* run last 2 bit allocation stages if fast gain changes */
1276

3816
            if (blk && prev != s->fast_gain[ch])
1277
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1278
        }
1279

13046
    } else if (s->eac3 && !blk) {
1280
4112
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1281
3071
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1282
    }
1283
1284
    /* E-AC-3 to AC-3 converter SNR offset */
1285

14000
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1286
685
        skip_bits(gbc, 10); // skip converter snr offset
1287
    }
1288
1289
    /* coupling leak information */
1290
14000
    if (cpl_in_use) {
1291

7274
        if (s->first_cpl_leak || get_bits1(gbc)) {
1292
1259
            int fl = get_bits(gbc, 3);
1293
1259
            int sl = get_bits(gbc, 3);
1294
            /* run last 2 bit allocation stages for coupling channel if
1295
               coupling leak changes */
1296

1259
            if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1297
1
                sl != s->bit_alloc_params.cpl_slow_leak)) {
1298
46
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1299
            }
1300
1259
            s->bit_alloc_params.cpl_fast_leak = fl;
1301
1259
            s->bit_alloc_params.cpl_slow_leak = sl;
1302

6015
        } else if (!s->eac3 && !blk) {
1303
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1304
                   "be present in block 0\n");
1305
            return AVERROR_INVALIDDATA;
1306
        }
1307
7274
        s->first_cpl_leak = 0;
1308
    }
1309
1310
    /* delta bit allocation information */
1311

14000
    if (s->dba_syntax && get_bits1(gbc)) {
1312
        /* delta bit allocation exists (strategy) */
1313
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1314
            s->dba_mode[ch] = get_bits(gbc, 2);
1315
            if (s->dba_mode[ch] == DBA_RESERVED) {
1316
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1317
                return AVERROR_INVALIDDATA;
1318
            }
1319
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1320
        }
1321
        /* channel delta offset, len and bit allocation */
1322
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1323
            if (s->dba_mode[ch] == DBA_NEW) {
1324
                s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1325
                for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1326
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1327
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1328
                    s->dba_values[ch][seg]  = get_bits(gbc, 3);
1329
                }
1330
                /* run last 2 bit allocation stages if new dba values */
1331
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1332
            }
1333
        }
1334
14000
    } else if (blk == 0) {
1335
12794
        for (ch = 0; ch <= s->channels; ch++) {
1336
10379
            s->dba_mode[ch] = DBA_NONE;
1337
        }
1338
    }
1339
1340
    /* Bit allocation */
1341
66118
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1342
52118
        if (bit_alloc_stages[ch] > 2) {
1343
            /* Exponent mapping into PSD and PSD integration */
1344
13377
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1345
                                      s->start_freq[ch], s->end_freq[ch],
1346
13377
                                      s->psd[ch], s->band_psd[ch]);
1347
        }
1348
52118
        if (bit_alloc_stages[ch] > 1) {
1349
            /* Compute excitation function, Compute masking curve, and
1350
               Apply delta bit allocation */
1351
13519
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1352
                                           s->start_freq[ch],  s->end_freq[ch],
1353
13519
                                           s->fast_gain[ch],   (ch == s->lfe_ch),
1354
                                           s->dba_mode[ch],    s->dba_nsegs[ch],
1355
13519
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1356
13519
                                           s->dba_values[ch],  s->mask[ch])) {
1357
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1358
                return AVERROR_INVALIDDATA;
1359
            }
1360
        }
1361
52118
        if (bit_alloc_stages[ch] > 0) {
1362
            /* Compute bit allocation */
1363
27038
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1364
13519
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1365
13519
            s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1366
                                      s->start_freq[ch], s->end_freq[ch],
1367
                                      s->snr_offset[ch],
1368
                                      s->bit_alloc_params.floor,
1369
13519
                                      bap_tab, s->bap[ch]);
1370
        }
1371
    }
1372
1373
    /* unused dummy data */
1374

14000
    if (s->skip_syntax && get_bits1(gbc)) {
1375
1242
        int skipl = get_bits(gbc, 9);
1376
1242
        skip_bits_long(gbc, 8 * skipl);
1377
    }
1378
1379
    /* unpack the transform coefficients
1380
       this also uncouples channels if coupling is in use. */
1381
14000
    decode_transform_coeffs(s, blk);
1382
1383
    /* TODO: generate enhanced coupling coordinates and uncouple */
1384
1385
    /* recover coefficients if rematrixing is in use */
1386
14000
    if (s->channel_mode == AC3_CHMODE_STEREO)
1387
8568
        do_rematrixing(s);
1388
1389
    /* apply scaling to coefficients (headroom, dynrng) */
1390
58844
    for (ch = 1; ch <= s->channels; ch++) {
1391
44844
        int audio_channel = 0;
1392
        INTFLOAT gain;
1393

44844
        if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1394
            audio_channel = 2-ch;
1395

44844
        if (s->heavy_compression && s->compression_exists[audio_channel])
1396
            gain = s->heavy_dynamic_range[audio_channel];
1397
        else
1398
44844
            gain = s->dynamic_range[audio_channel];
1399
1400
#if USE_FIXED
1401
7008
        scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1402
#else
1403
37836
        if (s->target_level != 0)
1404
          gain = gain * s->level_gain[audio_channel];
1405
37836
        gain *= 1.0 / 4194304.0f;
1406
37836
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1407
37836
                                               s->fixed_coeffs[ch], gain, 256);
1408
#endif
1409
    }
1410
1411
    /* apply spectral extension to high frequency bins */
1412
14000
    if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1413
3228
        ff_eac3_apply_spectral_extension(s);
1414
    }
1415
1416
    /* downmix and MDCT. order depends on whether block switching is used for
1417
       any channel in this block. this is because coefficients for the long
1418
       and short transforms cannot be mixed. */
1419
16436
    downmix_output = s->channels != s->out_channels &&
1420
2436
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1421
                     s->fbw_channels == s->out_channels);
1422
14000
    if (different_transforms) {
1423
        /* the delay samples have already been downmixed, so we upmix the delay
1424
           samples in order to reconstruct all channels before downmixing. */
1425
6
        if (s->downmixed) {
1426
6
            s->downmixed = 0;
1427
6
            ac3_upmix_delay(s);
1428
        }
1429
1430
6
        do_imdct(s, s->channels, offset);
1431
1432
6
        if (downmix_output) {
1433
#if USE_FIXED
1434
1
            ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1435
                              s->out_channels, s->fbw_channels, 256);
1436
#else
1437
2
            ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
1438
                              s->out_channels, s->fbw_channels, 256);
1439
#endif
1440
        }
1441
    } else {
1442
13994
        if (downmix_output) {
1443
2433
            AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1444
                                          s->out_channels, s->fbw_channels, 256);
1445
        }
1446
1447

13994
        if (downmix_output && !s->downmixed) {
1448
3
            s->downmixed = 1;
1449
3
            AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
1450
                                          s->out_channels, s->fbw_channels, 128);
1451
        }
1452
1453
13994
        do_imdct(s, s->out_channels, offset);
1454
    }
1455
1456
14000
    return 0;
1457
}
1458
1459
/**
1460
 * Decode a single AC-3 frame.
1461
 */
1462
2264
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1463
                            int *got_frame_ptr, AVPacket *avpkt)
1464
{
1465
2264
    AVFrame *frame     = data;
1466
2264
    const uint8_t *buf = avpkt->data;
1467
2264
    int buf_size, full_buf_size = avpkt->size;
1468
2264
    AC3DecodeContext *s = avctx->priv_data;
1469
    int blk, ch, err, offset, ret;
1470
    int i;
1471
2264
    int skip = 0, got_independent_frame = 0;
1472
    const uint8_t *channel_map;
1473
    uint8_t extended_channel_map[EAC3_MAX_CHANNELS];
1474
    const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1475
    enum AVMatrixEncoding matrix_encoding;
1476
    AVDownmixInfo *downmix_info;
1477
1478
2264
    s->superframe_size = 0;
1479
1480
2264
    buf_size = full_buf_size;
1481
2440
    for (i = 1; i < buf_size; i += 2) {
1482

2439
        if (buf[i] == 0x77 || buf[i] == 0x0B) {
1483
2264
            if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1484
2263
                i--;
1485
2263
                break;
1486
1
            } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1487
                break;
1488
            }
1489
        }
1490
    }
1491
2264
    if (i >= buf_size)
1492
1
        return AVERROR_INVALIDDATA;
1493
2263
    if (i > 10)
1494
        return i;
1495
2263
    buf += i;
1496
2263
    buf_size -= i;
1497
1498
    /* copy input buffer to decoder context to avoid reading past the end
1499
       of the buffer, which can be caused by a damaged input stream. */
1500

2263
    if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1501
        // seems to be byte-swapped AC-3
1502
        int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1503
        s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1504
                            (const uint16_t *) buf, cnt);
1505
    } else
1506
2263
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1507
1508
    /* if consistent noise generation is enabled, seed the linear feedback generator
1509
     * with the contents of the AC-3 frame so that the noise is identical across
1510
     * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1511
2263
    if (s->consistent_noise_generation)
1512
        av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1513
1514
2263
    buf = s->input_buffer;
1515
2422
dependent_frame:
1516
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1517
2422
    if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1518
        return ret;
1519
1520
    /* parse the syncinfo */
1521
2422
    err = parse_frame_header(s);
1522
1523
2422
    if (err) {
1524
        switch (err) {
1525
        case AAC_AC3_PARSE_ERROR_SYNC:
1526
            av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1527
            return AVERROR_INVALIDDATA;
1528
        case AAC_AC3_PARSE_ERROR_BSID:
1529
            av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1530
            break;
1531
        case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1532
            av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1533
            break;
1534
        case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1535
            av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1536
            break;
1537
        case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1538
            /* skip frame if CRC is ok. otherwise use error concealment. */
1539
            /* TODO: add support for substreams */
1540
            if (s->substreamid) {
1541
                av_log(avctx, AV_LOG_DEBUG,
1542
                       "unsupported substream %d: skipping frame\n",
1543
                       s->substreamid);
1544
                *got_frame_ptr = 0;
1545
                return buf_size;
1546
            } else {
1547
                av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1548
            }
1549
            break;
1550
        case AAC_AC3_PARSE_ERROR_CRC:
1551
        case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1552
            break;
1553
        default: // Normal AVERROR do not try to recover.
1554
            *got_frame_ptr = 0;
1555
            return err;
1556
        }
1557
    } else {
1558
        /* check that reported frame size fits in input buffer */
1559
2422
        if (s->frame_size > buf_size) {
1560
7
            av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1561
7
            err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1562
2415
        } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1563
            /* check for crc mismatch */
1564
            if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1565
                       s->frame_size - 2)) {
1566
                av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1567
                if (avctx->err_recognition & AV_EF_EXPLODE)
1568
                    return AVERROR_INVALIDDATA;
1569
                err = AAC_AC3_PARSE_ERROR_CRC;
1570
            }
1571
        }
1572
    }
1573
1574

2422
    if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
1575
        av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
1576
        *got_frame_ptr = 0;
1577
        return FFMIN(full_buf_size, s->frame_size);
1578
    }
1579
1580
    /* channel config */
1581

2422
    if (!err || (s->channels && s->out_channels != s->channels)) {
1582
2419
        s->out_channels = s->channels;
1583
2419
        s->output_mode  = s->channel_mode;
1584
2419
        if (s->lfe_on)
1585
584
            s->output_mode |= AC3_OUTPUT_LFEON;
1586
2419
        if (s->channels > 1 &&
1587
2419
            avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1588
236
            s->out_channels = 1;
1589
236
            s->output_mode  = AC3_CHMODE_MONO;
1590
2183
        } else if (s->channels > 2 &&
1591
755
                   avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1592
174
            s->out_channels = 2;
1593
174
            s->output_mode  = AC3_CHMODE_STEREO;
1594
        }
1595
1596
2419
        s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1597
2419
        s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1598
2419
        s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1599
2419
        s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1600
        /* set downmixing coefficients if needed */
1601

2419
        if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1602
                s->fbw_channels == s->out_channels)) {
1603
410
            if ((ret = set_downmix_coeffs(s)) < 0) {
1604
                av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1605
                return ret;
1606
            }
1607
        }
1608
3
    } else if (!s->channels) {
1609
        av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1610
        return AVERROR_INVALIDDATA;
1611
    }
1612
2422
    avctx->channels = s->out_channels;
1613
2422
    avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1614
2422
    if (s->output_mode & AC3_OUTPUT_LFEON)
1615
361
        avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1616
1617
    /* set audio service type based on bitstream mode for AC-3 */
1618
2422
    avctx->audio_service_type = s->bitstream_mode;
1619

2422
    if (s->bitstream_mode == 0x7 && s->channels > 1)
1620
        avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1621
1622
    /* decode the audio blocks */
1623
2422
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1624
2422
    offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1625
19376
    for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1626
16954
        output[ch] = s->output[ch + offset];
1627
16954
        s->outptr[ch] = s->output[ch + offset];
1628
    }
1629
10420
    for (ch = 0; ch < s->channels; ch++) {
1630
7998
        if (ch < s->out_channels)
1631
6494
            s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1632
    }
1633
16464
    for (blk = 0; blk < s->num_blocks; blk++) {
1634

14042
        if (!err && decode_audio_block(s, blk, offset)) {
1635
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1636
            err = 1;
1637
        }
1638
14042
        if (err)
1639
138
            for (ch = 0; ch < s->out_channels; ch++)
1640
96
                memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1641
50066
        for (ch = 0; ch < s->out_channels; ch++)
1642
36024
            output[ch] = s->outptr[channel_map[ch]];
1643
50066
        for (ch = 0; ch < s->out_channels; ch++) {
1644

36024
            if (!ch || channel_map[ch])
1645
36024
                s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1646
        }
1647
    }
1648
1649
    /* keep last block for error concealment in next frame */
1650
8916
    for (ch = 0; ch < s->out_channels; ch++)
1651
6494
        memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1652
1653
    /* check if there is dependent frame */
1654
2422
    if (buf_size > s->frame_size) {
1655
        AC3HeaderInfo hdr;
1656
        int err;
1657
1658
159
        if (buf_size - s->frame_size <= 16) {
1659
            skip = buf_size - s->frame_size;
1660
            goto skip;
1661
        }
1662
1663
159
        if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1664
            return ret;
1665
1666
159
        err = ff_ac3_parse_header(&s->gbc, &hdr);
1667
159
        if (err)
1668
            return err;
1669
1670
159
        if (hdr.frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1671

159
            if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) {
1672
                av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n");
1673
            } else {
1674
159
                buf += s->frame_size;
1675
159
                buf_size -= s->frame_size;
1676
159
                s->prev_output_mode = s->output_mode;
1677
159
                s->prev_bit_rate = s->bit_rate;
1678
159
                got_independent_frame = 1;
1679
159
                goto dependent_frame;
1680
            }
1681
        }
1682
    }
1683
2263
skip:
1684
1685
2263
    frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
1686
1687
    /* if frame is ok, set audio parameters */
1688
2263
    if (!err) {
1689
2256
        avctx->sample_rate = s->sample_rate;
1690
2256
        avctx->bit_rate    = s->bit_rate + s->prev_bit_rate;
1691
    }
1692
1693
38471
    for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1694
36208
        extended_channel_map[ch] = ch;
1695
1696
2263
    if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1697
159
        uint64_t ich_layout = avpriv_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON];
1698
159
        int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1699
        uint64_t channel_layout;
1700
159
        int extend = 0;
1701
1702
159
        if (s->prev_output_mode & AC3_OUTPUT_LFEON)
1703
159
            ich_layout |= AV_CH_LOW_FREQUENCY;
1704
1705
159
        channel_layout = ich_layout;
1706
2703
        for (ch = 0; ch < 16; ch++) {
1707
2544
            if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1708
477
                channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
1709
            }
1710
        }
1711
159
        if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
1712
            av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
1713
                   av_get_channel_layout_nb_channels(channel_layout));
1714
            return AVERROR_INVALIDDATA;
1715
        }
1716
1717
159
        avctx->channel_layout = channel_layout;
1718
159
        avctx->channels = av_get_channel_layout_nb_channels(channel_layout);
1719
1720
2703
        for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
1721
2544
            if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1722
477
                if (ff_eac3_custom_channel_map_locations[ch][0]) {
1723
318
                    int index = av_get_channel_layout_channel_index(channel_layout,
1724
                                                                    ff_eac3_custom_channel_map_locations[ch][1]);
1725
318
                    if (index < 0)
1726
                        return AVERROR_INVALIDDATA;
1727
318
                    if (extend >= channel_map_size)
1728
                        return AVERROR_INVALIDDATA;
1729
1730
318
                    extended_channel_map[index] = offset + channel_map[extend++];
1731
                } else {
1732
                    int i;
1733
1734
10335
                    for (i = 0; i < 64; i++) {
1735
10176
                        if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
1736
318
                            int index = av_get_channel_layout_channel_index(channel_layout,
1737
318
                                                                            1ULL << i);
1738
318
                            if (index < 0)
1739
                                return AVERROR_INVALIDDATA;
1740
318
                            if (extend >= channel_map_size)
1741
                                return AVERROR_INVALIDDATA;
1742
1743
318
                            extended_channel_map[index] = offset + channel_map[extend++];
1744
                        }
1745
                    }
1746
                }
1747
            }
1748
        }
1749
    }
1750
1751
    /* get output buffer */
1752
2263
    frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1753
2263
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1754
        return ret;
1755
1756
8439
    for (ch = 0; ch < avctx->channels; ch++) {
1757
6176
        int map = extended_channel_map[ch];
1758

6176
        av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
1759
6176
        memcpy((SHORTFLOAT *)frame->extended_data[ch],
1760
6176
               s->output_buffer[map],
1761
6176
               s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
1762
    }
1763
1764
    /*
1765
     * AVMatrixEncoding
1766
     *
1767
     * Check whether the input layout is compatible, and make sure we're not
1768
     * downmixing (else the matrix encoding is no longer applicable).
1769
     */
1770
2263
    matrix_encoding = AV_MATRIX_ENCODING_NONE;
1771
2263
    if (s->channel_mode == AC3_CHMODE_STEREO &&
1772
1430
        s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1773
1430
        if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1774
490
            matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1775
940
        else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1776
            matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1777
833
    } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1778
426
               s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1779
202
        switch (s->dolby_surround_ex_mode) {
1780
        case AC3_DSUREXMOD_ON: // EX or PLIIx
1781
            matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1782
            break;
1783
        case AC3_DSUREXMOD_PLIIZ:
1784
            matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1785
            break;
1786
202
        default: // not indicated or off
1787
202
            break;
1788
        }
1789
631
    }
1790
2263
    if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1791
        return ret;
1792
1793
    /* AVDownmixInfo */
1794
2263
    if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1795

2263
        switch (s->preferred_downmix) {
1796
48
        case AC3_DMIXMOD_LTRT:
1797
48
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1798
48
            break;
1799
        case AC3_DMIXMOD_LORO:
1800
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1801
            break;
1802
98
        case AC3_DMIXMOD_DPLII:
1803
98
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1804
98
            break;
1805
2117
        default:
1806
2117
            downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1807
2117
            break;
1808
        }
1809
2263
        downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1810
2263
        downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1811
2263
        downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1812
2263
        downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1813
2263
        if (s->lfe_mix_level_exists)
1814
146
            downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1815
        else
1816
2117
            downmix_info->lfe_mix_level       = 0.0; // -inf dB
1817
    } else
1818
        return AVERROR(ENOMEM);
1819
1820
2263
    *got_frame_ptr = 1;
1821
1822
2263
    if (!s->superframe_size)
1823
        return FFMIN(full_buf_size, s->frame_size + skip);
1824
1825
2263
    return FFMIN(full_buf_size, s->superframe_size + skip);
1826
}
1827
1828
/**
1829
 * Uninitialize the AC-3 decoder.
1830
 */
1831
52
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1832
{
1833
52
    AC3DecodeContext *s = avctx->priv_data;
1834
52
    ff_mdct_end(&s->imdct_512);
1835
52
    ff_mdct_end(&s->imdct_256);
1836
52
    av_freep(&s->fdsp);
1837
52
    av_freep(&s->downmix_coeffs[0]);
1838
1839
52
    return 0;
1840
}
1841
1842
#define OFFSET(x) offsetof(AC3DecodeContext, x)
1843
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)