GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ac3dec.c Lines: 811 990 81.9 %
Date: 2021-04-20 04:37:23 Branches: 556 726 76.6 %

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 "libavutil/thread.h"
37
#include "bswapdsp.h"
38
#include "internal.h"
39
#include "aac_ac3_parser.h"
40
#include "ac3_parser_internal.h"
41
#include "ac3dec.h"
42
#include "ac3dec_data.h"
43
#include "kbdwin.h"
44
45
/**
46
 * table for ungrouping 3 values in 7 bits.
47
 * used for exponents and bap=2 mantissas
48
 */
49
static uint8_t ungroup_3_in_7_bits_tab[128][3];
50
51
/** tables for ungrouping mantissas */
52
static int b1_mantissas[32][3];
53
static int b2_mantissas[128][3];
54
static int b3_mantissas[8];
55
static int b4_mantissas[128][2];
56
static int b5_mantissas[16];
57
58
/**
59
 * Quantization table: levels for symmetric. bits for asymmetric.
60
 * reference: Table 7.18 Mapping of bap to Quantizer
61
 */
62
static const uint8_t quantization_tab[16] = {
63
    0, 3, 5, 7, 11, 15,
64
    5, 6, 7, 8, 9, 10, 11, 12, 14, 16
65
};
66
67
#if (!USE_FIXED)
68
/** dynamic range table. converts codes to scale factors. */
69
static float dynamic_range_tab[256];
70
float ff_ac3_heavy_dynamic_range_tab[256];
71
#endif
72
73
/** Adjustments in dB gain */
74
static const float gain_levels[9] = {
75
    LEVEL_PLUS_3DB,
76
    LEVEL_PLUS_1POINT5DB,
77
    LEVEL_ONE,
78
    LEVEL_MINUS_1POINT5DB,
79
    LEVEL_MINUS_3DB,
80
    LEVEL_MINUS_4POINT5DB,
81
    LEVEL_MINUS_6DB,
82
    LEVEL_ZERO,
83
    LEVEL_MINUS_9DB
84
};
85
86
/** Adjustments in dB gain (LFE, +10 to -21 dB) */
87
static const float gain_levels_lfe[32] = {
88
    3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
89
    1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
90
    0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
91
    0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
92
    0.125892, 0.112201, 0.100000, 0.089125
93
};
94
95
/**
96
 * Table for default stereo downmixing coefficients
97
 * reference: Section 7.8.2 Downmixing Into Two Channels
98
 */
99
static const uint8_t ac3_default_coeffs[8][5][2] = {
100
    { { 2, 7 }, { 7, 2 },                               },
101
    { { 4, 4 },                                         },
102
    { { 2, 7 }, { 7, 2 },                               },
103
    { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
104
    { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
105
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
106
    { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
107
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
108
};
109
110
/**
111
 * Symmetrical Dequantization
112
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
113
 *            Tables 7.19 to 7.23
114
 */
115
static inline int
116
27288
symmetric_dequant(int code, int levels)
117
{
118
27288
    return ((code - (levels >> 1)) * (1 << 24)) / levels;
119
}
120
121
/*
122
 * Initialize tables at runtime.
123
 */
124
36
static av_cold void ac3_tables_init(void)
125
{
126
    int i;
127
128
    /* generate table for ungrouping 3 values in 7 bits
129
       reference: Section 7.1.3 Exponent Decoding */
130
4644
    for (i = 0; i < 128; i++) {
131
4608
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
132
4608
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
133
4608
        ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
134
    }
135
136
    /* generate grouped mantissa tables
137
       reference: Section 7.3.5 Ungrouping of Mantissas */
138
1188
    for (i = 0; i < 32; i++) {
139
        /* bap=1 mantissas */
140
1152
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
141
1152
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
142
1152
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
143
    }
144
4644
    for (i = 0; i < 128; i++) {
145
        /* bap=2 mantissas */
146
4608
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
147
4608
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
148
4608
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
149
150
        /* bap=4 mantissas */
151
4608
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
152
4608
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
153
    }
154
    /* generate ungrouped mantissa tables
155
       reference: Tables 7.21 and 7.23 */
156
288
    for (i = 0; i < 7; i++) {
157
        /* bap=3 mantissas */
158
252
        b3_mantissas[i] = symmetric_dequant(i, 7);
159
    }
160
576
    for (i = 0; i < 15; i++) {
161
        /* bap=5 mantissas */
162
540
        b5_mantissas[i] = symmetric_dequant(i, 15);
163
    }
164
165
#if (!USE_FIXED)
166
    /* generate dynamic range table
167
       reference: Section 7.7.1 Dynamic Range Control */
168
8224
    for (i = 0; i < 256; i++) {
169
8192
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
170
8192
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
171
    }
172
173
    /* generate compr dynamic range table
174
       reference: Section 7.7.2 Heavy Compression */
175
8224
    for (i = 0; i < 256; i++) {
176
8192
        int v = (i >> 4) - ((i >> 7) << 4) - 4;
177
8192
        ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
178
    }
179
#endif
180
36
}
181
182
/**
183
 * AVCodec initialization
184
 */
185
67
static av_cold int ac3_decode_init(AVCodecContext *avctx)
186
{
187
    static AVOnce init_static_once = AV_ONCE_INIT;
188
67
    AC3DecodeContext *s = avctx->priv_data;
189
    int i, ret;
190
191
67
    s->avctx = avctx;
192
193

134
    if ((ret = ff_mdct_init(&s->imdct_256, 8, 1, 1.0)) < 0 ||
194
67
        (ret = ff_mdct_init(&s->imdct_512, 9, 1, 1.0)) < 0)
195
        return ret;
196
67
    AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
197
67
    ff_bswapdsp_init(&s->bdsp);
198
199
#if (USE_FIXED)
200
4
    s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
201
#else
202
63
    ff_fmt_convert_init(&s->fmt_conv, avctx);
203
63
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
204
#endif
205
67
    if (!s->fdsp)
206
        return AVERROR(ENOMEM);
207
208
67
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
209
67
    av_lfg_init(&s->dith_state, 0);
210
211
    if (USE_FIXED)
212
4
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
213
    else
214
63
        avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
215
216
    /* allow downmixing to stereo or mono */
217
67
    if (avctx->channels > 1 &&
218
35
        avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
219
4
        avctx->channels = 1;
220
63
    else if (avctx->channels > 2 &&
221
12
             avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
222
3
        avctx->channels = 2;
223
67
    s->downmixed = 1;
224
225
536
    for (i = 0; i < AC3_MAX_CHANNELS; i++) {
226
469
        s->xcfptr[i] = s->transform_coeffs[i];
227
469
        s->dlyptr[i] = s->delay[i];
228
    }
229
230
67
    ff_thread_once(&init_static_once, ac3_tables_init);
231
232
67
    return 0;
233
}
234
235
/**
236
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
237
 * GetBitContext within AC3DecodeContext must point to
238
 * the start of the synchronized AC-3 bitstream.
239
 */
240
1251
static int ac3_parse_header(AC3DecodeContext *s)
241
{
242
1251
    GetBitContext *gbc = &s->gbc;
243
    int i;
244
245
    /* read the rest of the bsi. read twice for dual mono mode. */
246
1251
    i = !s->channel_mode;
247
    do {
248
1251
        s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
249
1251
        if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
250
            s->dialog_normalization[(!s->channel_mode)-i] = -31;
251
        }
252
1251
        if (s->target_level != 0) {
253
            s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
254
                (float)(s->target_level -
255
                s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
256
        }
257
1251
        if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
258
974
            s->heavy_dynamic_range[(!s->channel_mode)-i] =
259
974
                AC3_HEAVY_RANGE(get_bits(gbc, 8));
260
        }
261
1251
        if (get_bits1(gbc))
262
            skip_bits(gbc, 8); //skip language code
263
1251
        if (get_bits1(gbc))
264
552
            skip_bits(gbc, 7); //skip audio production information
265
1251
    } while (i--);
266
267
1251
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
268
269
    /* skip the timecodes or parse the Alternate Bit Stream Syntax */
270
1251
    if (s->bitstream_id != 6) {
271
1079
        if (get_bits1(gbc))
272
            skip_bits(gbc, 14); //skip timecode1
273
1079
        if (get_bits1(gbc))
274
            skip_bits(gbc, 14); //skip timecode2
275
    } else {
276
172
        if (get_bits1(gbc)) {
277
172
            s->preferred_downmix       = get_bits(gbc, 2);
278
172
            s->center_mix_level_ltrt   = get_bits(gbc, 3);
279
172
            s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
280
172
            s->center_mix_level        = get_bits(gbc, 3);
281
172
            s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
282
        }
283
172
        if (get_bits1(gbc)) {
284
170
            s->dolby_surround_ex_mode = get_bits(gbc, 2);
285
170
            s->dolby_headphone_mode   = get_bits(gbc, 2);
286
170
            skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
287
        }
288
    }
289
290
    /* skip additional bitstream info */
291
1251
    if (get_bits1(gbc)) {
292
        i = get_bits(gbc, 6);
293
        do {
294
            skip_bits(gbc, 8);
295
        } while (i--);
296
    }
297
298
1251
    return 0;
299
}
300
301
/**
302
 * Common function to parse AC-3 or E-AC-3 frame header
303
 */
304
2452
static int parse_frame_header(AC3DecodeContext *s)
305
{
306
    AC3HeaderInfo hdr;
307
    int err;
308
309
2452
    err = ff_ac3_parse_header(&s->gbc, &hdr);
310
2452
    if (err)
311
        return err;
312
313
    /* get decoding parameters from header info */
314
2452
    s->bit_alloc_params.sr_code     = hdr.sr_code;
315
2452
    s->bitstream_id                 = hdr.bitstream_id;
316
2452
    s->bitstream_mode               = hdr.bitstream_mode;
317
2452
    s->channel_mode                 = hdr.channel_mode;
318
2452
    s->lfe_on                       = hdr.lfe_on;
319
2452
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
320
2452
    s->sample_rate                  = hdr.sample_rate;
321
2452
    s->bit_rate                     = hdr.bit_rate;
322
2452
    s->channels                     = hdr.channels;
323
2452
    s->fbw_channels                 = s->channels - s->lfe_on;
324
2452
    s->lfe_ch                       = s->fbw_channels + 1;
325
2452
    s->frame_size                   = hdr.frame_size;
326
2452
    s->superframe_size             += hdr.frame_size;
327
2452
    s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
328
2452
    s->center_mix_level             = hdr.center_mix_level;
329
2452
    s->center_mix_level_ltrt        = 4; // -3.0dB
330
2452
    s->surround_mix_level           = hdr.surround_mix_level;
331
2452
    s->surround_mix_level_ltrt      = 4; // -3.0dB
332
2452
    s->lfe_mix_level_exists         = 0;
333
2452
    s->num_blocks                   = hdr.num_blocks;
334
2452
    s->frame_type                   = hdr.frame_type;
335
2452
    s->substreamid                  = hdr.substreamid;
336
2452
    s->dolby_surround_mode          = hdr.dolby_surround_mode;
337
2452
    s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
338
2452
    s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
339
340
2452
    if (s->lfe_on) {
341
595
        s->start_freq[s->lfe_ch]     = 0;
342
595
        s->end_freq[s->lfe_ch]       = 7;
343
595
        s->num_exp_groups[s->lfe_ch] = 2;
344
595
        s->channel_in_cpl[s->lfe_ch] = 0;
345
    }
346
347
2452
    if (s->bitstream_id <= 10) {
348
1251
        s->eac3                  = 0;
349
1251
        s->snr_offset_strategy   = 2;
350
1251
        s->block_switch_syntax   = 1;
351
1251
        s->dither_flag_syntax    = 1;
352
1251
        s->bit_allocation_syntax = 1;
353
1251
        s->fast_gain_syntax      = 0;
354
1251
        s->first_cpl_leak        = 0;
355
1251
        s->dba_syntax            = 1;
356
1251
        s->skip_syntax           = 1;
357
1251
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
358
1251
        return ac3_parse_header(s);
359
    } else if (CONFIG_EAC3_DECODER) {
360
1201
        s->eac3 = 1;
361
1201
        return ff_eac3_parse_header(s);
362
    } else {
363
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
364
        return AVERROR(ENOSYS);
365
    }
366
}
367
368
/**
369
 * Set stereo downmixing coefficients based on frame header info.
370
 * reference: Section 7.8.2 Downmixing Into Two Channels
371
 */
372
417
static int set_downmix_coeffs(AC3DecodeContext *s)
373
{
374
    int i;
375
417
    float cmix = gain_levels[s->  center_mix_level];
376
417
    float smix = gain_levels[s->surround_mix_level];
377
    float norm0, norm1;
378
    float downmix_coeffs[2][AC3_MAX_CHANNELS];
379
380
417
    if (!s->downmix_coeffs[0]) {
381
14
        s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
382
                                               sizeof(**s->downmix_coeffs));
383
14
        if (!s->downmix_coeffs[0])
384
            return AVERROR(ENOMEM);
385
14
        s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
386
    }
387
388
2313
    for (i = 0; i < s->fbw_channels; i++) {
389
1896
        downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
390
1896
        downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
391
    }
392

417
    if (s->channel_mode > 1 && s->channel_mode & 1) {
393
417
        downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
394
    }
395

417
    if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
396
189
        int nf = s->channel_mode - 2;
397
189
        downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
398
    }
399

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

1414536
        switch (group_size) {
464
104358
        case 4: dexps[j++] = prevexp;
465
104358
                dexps[j++] = prevexp;
466
273126
        case 2: dexps[j++] = prevexp;
467
1414536
        case 1: dexps[j++] = prevexp;
468
        }
469
    }
470
13553
    return 0;
471
}
472
473
/**
474
 * Generate transform coefficients for each coupled channel in the coupling
475
 * range using the coupling coefficients and coupling coordinates.
476
 * reference: Section 7.4.3 Coupling Coordinate Format
477
 */
478
7400
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
479
{
480
    int bin, band, ch;
481
482
7400
    bin = s->start_freq[CPL_CH];
483
33622
    for (band = 0; band < s->num_cpl_bands; band++) {
484
26222
        int band_start = bin;
485
26222
        int band_end = bin + s->cpl_band_sizes[band];
486
88854
        for (ch = 1; ch <= s->fbw_channels; ch++) {
487
62632
            if (s->channel_in_cpl[ch]) {
488
62632
                int cpl_coord = s->cpl_coords[ch][band] << 5;
489
1487368
                for (bin = band_start; bin < band_end; bin++) {
490
1424736
                    s->fixed_coeffs[ch][bin] =
491
1424736
                        MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
492
                }
493

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

48026
    int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
527
48026
    GetBitContext *gbc = &s->gbc;
528
    int freq;
529
530
6770912
    for (freq = start_freq; freq < end_freq; freq++) {
531
6722886
        int bap = baps[freq];
532
        int mantissa;
533

6722886
        switch (bap) {
534
2071845
        case 0:
535
            /* random noise with approximate range of -0.707 to 0.707 */
536
2071845
            if (dither)
537
2067538
                mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
538
            else
539
4307
                mantissa = 0;
540
2071845
            break;
541
1386806
        case 1:
542
1386806
            if (m->b1) {
543
920686
                m->b1--;
544
920686
                mantissa = m->b1_mant[m->b1];
545
            } else {
546
466120
                int bits      = get_bits(gbc, 5);
547
466120
                mantissa      = b1_mantissas[bits][0];
548
466120
                m->b1_mant[1] = b1_mantissas[bits][1];
549
466120
                m->b1_mant[0] = b1_mantissas[bits][2];
550
466120
                m->b1         = 2;
551
            }
552
1386806
            break;
553
641137
        case 2:
554
641137
            if (m->b2) {
555
423785
                m->b2--;
556
423785
                mantissa = m->b2_mant[m->b2];
557
            } else {
558
217352
                int bits      = get_bits(gbc, 7);
559
217352
                mantissa      = b2_mantissas[bits][0];
560
217352
                m->b2_mant[1] = b2_mantissas[bits][1];
561
217352
                m->b2_mant[0] = b2_mantissas[bits][2];
562
217352
                m->b2         = 2;
563
            }
564
641137
            break;
565
744476
        case 3:
566
744476
            mantissa = b3_mantissas[get_bits(gbc, 3)];
567
744476
            break;
568
485054
        case 4:
569
485054
            if (m->b4) {
570
239510
                m->b4 = 0;
571
239510
                mantissa = m->b4_mant;
572
            } else {
573
245544
                int bits   = get_bits(gbc, 7);
574
245544
                mantissa   = b4_mantissas[bits][0];
575
245544
                m->b4_mant = b4_mantissas[bits][1];
576
245544
                m->b4      = 1;
577
            }
578
485054
            break;
579
400573
        case 5:
580
400573
            mantissa = b5_mantissas[get_bits(gbc, 4)];
581
400573
            break;
582
992995
        default: /* 6 to 15 */
583
            /* Shift mantissa and sign-extend it. */
584
992995
            if (bap > 15) {
585
                av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
586
                bap = 15;
587
            }
588
992995
            mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
589
992995
            break;
590
        }
591
6722886
        coeffs[freq] = mantissa >> exps[freq];
592
    }
593
48026
}
594
595
/**
596
 * Remove random dithering from coupling range coefficients with zero-bit
597
 * mantissas for coupled channels which do not use dithering.
598
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
599
 */
600
14180
static void remove_dithering(AC3DecodeContext *s) {
601
    int ch, i;
602
603
56616
    for (ch = 1; ch <= s->fbw_channels; ch++) {
604

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

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

1773
    if (!eac3 || get_bits1(gbc)) {
793
6503
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
794
5135
            band_struct[subbnd] = get_bits1(gbc);
795
        }
796
    }
797
798
    /* calculate number of bands and band sizes based on band structure.
799
       note that the first 4 subbands in enhanced coupling span only 6 bins
800
       instead of 12. */
801

1773
    if (num_bands || band_sizes ) {
802
1773
        n_bands = n_subbands;
803
1773
        bnd_sz[0] = ecpl ? 6 : 12;
804
9052
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
805

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

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

1234
        if (s->eac3 && get_bits1(bc)) {
979
            /* TODO: parse enhanced coupling strategy info */
980
            avpriv_request_sample(s->avctx, "Enhanced coupling");
981
            return AVERROR_PATCHWELCOME;
982
        }
983
984
        /* determine which channels are coupled */
985

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

25757
            if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1037
                int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1038
5881
                s->first_cpl_coords[ch] = 0;
1039
5881
                cpl_coords_exist = 1;
1040
5881
                master_cpl_coord = 3 * get_bits(bc, 2);
1041
21523
                for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1042
15642
                    cpl_coord_exp  = get_bits(bc, 4);
1043
15642
                    cpl_coord_mant = get_bits(bc, 4);
1044
15642
                    if (cpl_coord_exp == 15)
1045
2586
                        s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1046
                    else
1047
13056
                        s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1048
15642
                    s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1049
                }
1050
13995
            } else if (!blk) {
1051
                av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1052
                       "be present in block 0\n");
1053
                return AVERROR_INVALIDDATA;
1054
            }
1055
        } else {
1056
            /* channel not in coupling */
1057
            s->first_cpl_coords[ch] = 1;
1058
        }
1059
    }
1060
    /* phase flags */
1061

7400
    if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1062
4909
        for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1063
3927
            s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1064
        }
1065
    }
1066
1067
7400
    return 0;
1068
}
1069
1070
/**
1071
 * Decode a single audio block from the AC-3 bitstream.
1072
 */
1073
14180
static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1074
{
1075
14180
    int fbw_channels = s->fbw_channels;
1076
14180
    int channel_mode = s->channel_mode;
1077
    int i, bnd, seg, ch, ret;
1078
    int different_transforms;
1079
    int downmix_output;
1080
    int cpl_in_use;
1081
14180
    GetBitContext *gbc = &s->gbc;
1082
14180
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1083
1084
    /* block switch flags */
1085
14180
    different_transforms = 0;
1086
14180
    if (s->block_switch_syntax) {
1087
33402
        for (ch = 1; ch <= fbw_channels; ch++) {
1088
25938
            s->block_switch[ch] = get_bits1(gbc);
1089

25938
            if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1090
6
                different_transforms = 1;
1091
        }
1092
    }
1093
1094
    /* dithering flags */
1095
14180
    if (s->dither_flag_syntax) {
1096
33402
        for (ch = 1; ch <= fbw_channels; ch++) {
1097
25938
            s->dither_flag[ch] = get_bits1(gbc);
1098
        }
1099
    }
1100
1101
    /* dynamic range */
1102
14180
    i = !s->channel_mode;
1103
    do {
1104
14180
        if (get_bits1(gbc)) {
1105
            /* Allow asymmetric application of DRC when drc_scale > 1.
1106
               Amplification of quiet sounds is enhanced */
1107
2750
            int range_bits = get_bits(gbc, 8);
1108
2750
            INTFLOAT range = AC3_RANGE(range_bits);
1109

2750
            if (range_bits <= 127 || s->drc_scale <= 1.0)
1110
2652
                s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1111
            else
1112
98
                s->dynamic_range[i] = range;
1113
11430
        } else if (blk == 0) {
1114
707
            s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1115
        }
1116
14180
    } while (i--);
1117
1118
    /* spectral extension strategy */
1119

14180
    if (s->eac3 && (!blk || get_bits1(gbc))) {
1120
1201
        s->spx_in_use = get_bits1(gbc);
1121
1201
        if (s->spx_in_use) {
1122
539
            if ((ret = spx_strategy(s, blk)) < 0)
1123
                return ret;
1124
        }
1125
    }
1126

14180
    if (!s->eac3 || !s->spx_in_use) {
1127
10946
        s->spx_in_use = 0;
1128
46050
        for (ch = 1; ch <= fbw_channels; ch++) {
1129
35104
            s->channel_uses_spx[ch] = 0;
1130
35104
            s->first_spx_coords[ch] = 1;
1131
        }
1132
    }
1133
1134
    /* spectral extension coordinates */
1135
14180
    if (s->spx_in_use)
1136
3234
        spx_coordinates(s);
1137
1138
    /* coupling strategy */
1139

14180
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1140
2447
        if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1141
            return ret;
1142
11733
    } else if (!s->eac3) {
1143
6218
        if (!blk) {
1144
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1145
                   "be present in block 0\n");
1146
            return AVERROR_INVALIDDATA;
1147
        } else {
1148
6218
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1149
        }
1150
    }
1151
14180
    cpl_in_use = s->cpl_in_use[blk];
1152
1153
    /* coupling coordinates */
1154
14180
    if (cpl_in_use) {
1155
7400
        if ((ret = coupling_coordinates(s, blk)) < 0)
1156
            return ret;
1157
    }
1158
1159
    /* stereo rematrixing strategy and band structure */
1160
14180
    if (channel_mode == AC3_CHMODE_STEREO) {
1161

8658
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1162
2851
            s->num_rematrixing_bands = 4;
1163

2851
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1164
1
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1165

2850
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1166
                s->num_rematrixing_bands--;
1167
            }
1168
14253
            for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1169
11402
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1170
5807
        } else if (!blk) {
1171
            av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1172
                   "new rematrixing strategy not present in block 0\n");
1173
            s->num_rematrixing_bands = 0;
1174
        }
1175
    }
1176
1177
    /* exponent strategies for each channel */
1178
67066
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1179
52886
        if (!s->eac3)
1180
33572
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1181
52886
        if (s->exp_strategy[blk][ch] != EXP_REUSE)
1182
13553
            bit_alloc_stages[ch] = 3;
1183
    }
1184
1185
    /* channel bandwidth */
1186
56616
    for (ch = 1; ch <= fbw_channels; ch++) {
1187
42436
        s->start_freq[ch] = 0;
1188
42436
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1189
            int group_size;
1190
10509
            int prev = s->end_freq[ch];
1191
10509
            if (s->channel_in_cpl[ch])
1192
4151
                s->end_freq[ch] = s->start_freq[CPL_CH];
1193
6358
            else if (s->channel_uses_spx[ch])
1194
1961
                s->end_freq[ch] = s->spx_src_start_freq;
1195
            else {
1196
4397
                int bandwidth_code = get_bits(gbc, 6);
1197
4397
                if (bandwidth_code > 60) {
1198
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1199
                    return AVERROR_INVALIDDATA;
1200
                }
1201
4397
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1202
            }
1203
10509
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1204
10509
            s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1205

10509
            if (blk > 0 && s->end_freq[ch] != prev)
1206
4
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1207
        }
1208
    }
1209

14180
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1210
2422
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1211
2422
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1212
    }
1213
1214
    /* decode exponents for each channel */
1215
67066
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1216
52886
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1217
13553
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1218
13553
            if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1219
13553
                                 s->num_exp_groups[ch], s->dexps[ch][0],
1220
13553
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1221
                return AVERROR_INVALIDDATA;
1222
            }
1223

13553
            if (ch != CPL_CH && ch != s->lfe_ch)
1224
10509
                skip_bits(gbc, 2); /* skip gainrng */
1225
        }
1226
    }
1227
1228
    /* bit allocation information */
1229
14180
    if (s->bit_allocation_syntax) {
1230
8690
        if (get_bits1(gbc)) {
1231
1564
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1232
1564
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1233
1564
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1234
1564
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1235
1564
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1236
8583
            for (ch = !cpl_in_use; ch <= s->channels; ch++)
1237
7019
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1238
7126
        } else if (!blk) {
1239
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1240
                   "be present in block 0\n");
1241
            return AVERROR_INVALIDDATA;
1242
        }
1243
    }
1244
1245
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1246

14180
    if (!s->eac3 || !blk) {
1247

9909
        if (s->snr_offset_strategy && get_bits1(gbc)) {
1248
1244
            int snr = 0;
1249
            int csnr;
1250
1244
            csnr = (get_bits(gbc, 6) - 15) << 4;
1251
6840
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1252
                /* snr offset */
1253

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

5596
                if (blk && s->snr_offset[ch] != snr) {
1257
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1258
                }
1259
5596
                s->snr_offset[ch] = snr;
1260
1261
                /* fast gain (normal AC-3 only) */
1262
5596
                if (!s->eac3) {
1263
5596
                    int prev = s->fast_gain[ch];
1264
5596
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1265
                    /* run last 2 bit allocation stages if fast gain changes */
1266

5596
                    if (blk && prev != s->fast_gain[ch])
1267
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1268
                }
1269
            }
1270

7421
        } else if (!s->eac3 && !blk) {
1271
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1272
            return AVERROR_INVALIDDATA;
1273
        }
1274
    }
1275
1276
    /* fast gain (E-AC-3 only) */
1277

14180
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1278
4770
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1279
3816
            int prev = s->fast_gain[ch];
1280
3816
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1281
            /* run last 2 bit allocation stages if fast gain changes */
1282

3816
            if (blk && prev != s->fast_gain[ch])
1283
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1284
        }
1285

13226
    } else if (s->eac3 && !blk) {
1286
4115
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1287
3073
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1288
    }
1289
1290
    /* E-AC-3 to AC-3 converter SNR offset */
1291

14180
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1292
686
        skip_bits(gbc, 10); // skip converter snr offset
1293
    }
1294
1295
    /* coupling leak information */
1296
14180
    if (cpl_in_use) {
1297

7400
        if (s->first_cpl_leak || get_bits1(gbc)) {
1298
1280
            int fl = get_bits(gbc, 3);
1299
1280
            int sl = get_bits(gbc, 3);
1300
            /* run last 2 bit allocation stages for coupling channel if
1301
               coupling leak changes */
1302

1280
            if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1303
1
                sl != s->bit_alloc_params.cpl_slow_leak)) {
1304
46
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1305
            }
1306
1280
            s->bit_alloc_params.cpl_fast_leak = fl;
1307
1280
            s->bit_alloc_params.cpl_slow_leak = sl;
1308

6120
        } else if (!s->eac3 && !blk) {
1309
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1310
                   "be present in block 0\n");
1311
            return AVERROR_INVALIDDATA;
1312
        }
1313
7400
        s->first_cpl_leak = 0;
1314
    }
1315
1316
    /* delta bit allocation information */
1317

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

14180
    if (s->skip_syntax && get_bits1(gbc)) {
1381
1267
        int skipl = get_bits(gbc, 9);
1382
1267
        skip_bits_long(gbc, 8 * skipl);
1383
    }
1384
1385
    /* unpack the transform coefficients
1386
       this also uncouples channels if coupling is in use. */
1387
14180
    decode_transform_coeffs(s, blk);
1388
1389
    /* TODO: generate enhanced coupling coordinates and uncouple */
1390
1391
    /* recover coefficients if rematrixing is in use */
1392
14180
    if (s->channel_mode == AC3_CHMODE_STEREO)
1393
8658
        do_rematrixing(s);
1394
1395
    /* apply scaling to coefficients (headroom, dynrng) */
1396
59666
    for (ch = 1; ch <= s->channels; ch++) {
1397
45486
        int audio_channel = 0;
1398
        INTFLOAT gain;
1399

45486
        if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1400
            audio_channel = 2-ch;
1401

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

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

2469
        if (buf[i] == 0x77 || buf[i] == 0x0B) {
1489
2294
            if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1490
2293
                i--;
1491
2293
                break;
1492
1
            } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1493
                break;
1494
            }
1495
        }
1496
    }
1497
2294
    if (i >= buf_size)
1498
1
        return AVERROR_INVALIDDATA;
1499
2293
    if (i > 10)
1500
        return i;
1501
2293
    buf += i;
1502
2293
    buf_size -= i;
1503
1504
    /* copy input buffer to decoder context to avoid reading past the end
1505
       of the buffer, which can be caused by a damaged input stream. */
1506

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

2452
    if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
1581
        av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
1582
        *got_frame_ptr = 0;
1583
        return FFMIN(full_buf_size, s->frame_size);
1584
    }
1585
1586
    /* channel config */
1587

2452
    if (!err || (s->channels && s->out_channels != s->channels)) {
1588
2449
        s->out_channels = s->channels;
1589
2449
        s->output_mode  = s->channel_mode;
1590
2449
        if (s->lfe_on)
1591
594
            s->output_mode |= AC3_OUTPUT_LFEON;
1592
2449
        if (s->channels > 1 &&
1593
2448
            avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1594
240
            s->out_channels = 1;
1595
240
            s->output_mode  = AC3_CHMODE_MONO;
1596
2209
        } else if (s->channels > 2 &&
1597
765
                   avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1598
177
            s->out_channels = 2;
1599
177
            s->output_mode  = AC3_CHMODE_STEREO;
1600
        }
1601
1602
2449
        s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1603
2449
        s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1604
2449
        s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1605
2449
        s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1606
        /* set downmixing coefficients if needed */
1607

2449
        if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1608
                s->fbw_channels == s->out_channels)) {
1609
417
            if ((ret = set_downmix_coeffs(s)) < 0) {
1610
                av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1611
                return ret;
1612
            }
1613
        }
1614
3
    } else if (!s->channels) {
1615
        av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1616
        return AVERROR_INVALIDDATA;
1617
    }
1618
2452
    avctx->channels = s->out_channels;
1619
2452
    avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1620
2452
    if (s->output_mode & AC3_OUTPUT_LFEON)
1621
367
        avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1622
1623
    /* set audio service type based on bitstream mode for AC-3 */
1624
2452
    avctx->audio_service_type = s->bitstream_mode;
1625

2452
    if (s->bitstream_mode == 0x7 && s->channels > 1)
1626
        avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1627
1628
    /* decode the audio blocks */
1629
2452
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1630
2452
    offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1631
19616
    for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1632
17164
        output[ch] = s->output[ch + offset];
1633
17164
        s->outptr[ch] = s->output[ch + offset];
1634
    }
1635
10557
    for (ch = 0; ch < s->channels; ch++) {
1636
8105
        if (ch < s->out_channels)
1637
6575
            s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1638
    }
1639
16674
    for (blk = 0; blk < s->num_blocks; blk++) {
1640

14222
        if (!err && decode_audio_block(s, blk, offset)) {
1641
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1642
            err = 1;
1643
        }
1644
14222
        if (err)
1645
138
            for (ch = 0; ch < s->out_channels; ch++)
1646
96
                memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1647
50732
        for (ch = 0; ch < s->out_channels; ch++)
1648
36510
            output[ch] = s->outptr[channel_map[ch]];
1649
50732
        for (ch = 0; ch < s->out_channels; ch++) {
1650

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

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

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

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