GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ac3dec.c Lines: 810 987 82.1 %
Date: 2020-11-28 20:53:16 Branches: 553 720 76.8 %

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
41690
symmetric_dequant(int code, int levels)
116
{
117
41690
    return ((code - (levels >> 1)) * (1 << 24)) / levels;
118
}
119
120
/*
121
 * Initialize tables at runtime.
122
 */
123
55
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
7095
    for (i = 0; i < 128; i++) {
130
7040
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
131
7040
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
132
7040
        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
1815
    for (i = 0; i < 32; i++) {
138
        /* bap=1 mantissas */
139
1760
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
140
1760
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
141
1760
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
142
    }
143
7095
    for (i = 0; i < 128; i++) {
144
        /* bap=2 mantissas */
145
7040
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
146
7040
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
147
7040
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
148
149
        /* bap=4 mantissas */
150
7040
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
151
7040
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
152
    }
153
    /* generate ungrouped mantissa tables
154
       reference: Tables 7.21 and 7.23 */
155
440
    for (i = 0; i < 7; i++) {
156
        /* bap=3 mantissas */
157
385
        b3_mantissas[i] = symmetric_dequant(i, 7);
158
    }
159
880
    for (i = 0; i < 15; i++) {
160
        /* bap=5 mantissas */
161
825
        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
13107
    for (i = 0; i < 256; i++) {
168
13056
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
169
13056
        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
13107
    for (i = 0; i < 256; i++) {
175
13056
        int v = (i >> 4) - ((i >> 7) << 4) - 4;
176
13056
        ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
177
    }
178
#endif
179
55
}
180
181
/**
182
 * AVCodec initialization
183
 */
184
55
static av_cold int ac3_decode_init(AVCodecContext *avctx)
185
{
186
55
    AC3DecodeContext *s = avctx->priv_data;
187
    int i;
188
189
55
    s->avctx = avctx;
190
191
55
    ac3_tables_init();
192
55
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
193
55
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
194
55
    AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
195
55
    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
51
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
201
51
    ff_fmt_convert_init(&s->fmt_conv, avctx);
202
#endif
203
204
55
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
205
55
    av_lfg_init(&s->dith_state, 0);
206
207
    if (USE_FIXED)
208
4
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
209
    else
210
51
        avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
211
212
    /* allow downmixing to stereo or mono */
213
55
    if (avctx->channels > 1 &&
214
28
        avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
215
4
        avctx->channels = 1;
216
51
    else if (avctx->channels > 2 &&
217
12
             avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
218
3
        avctx->channels = 2;
219
55
    s->downmixed = 1;
220
221
440
    for (i = 0; i < AC3_MAX_CHANNELS; i++) {
222
385
        s->xcfptr[i] = s->transform_coeffs[i];
223
385
        s->dlyptr[i] = s->delay[i];
224
    }
225
226
55
    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
1243
static int ac3_parse_header(AC3DecodeContext *s)
235
{
236
1243
    GetBitContext *gbc = &s->gbc;
237
    int i;
238
239
    /* read the rest of the bsi. read twice for dual mono mode. */
240
1243
    i = !s->channel_mode;
241
    do {
242
1243
        s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
243
1243
        if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
244
            s->dialog_normalization[(!s->channel_mode)-i] = -31;
245
        }
246
1243
        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
1243
        if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
252
966
            s->heavy_dynamic_range[(!s->channel_mode)-i] =
253
966
                AC3_HEAVY_RANGE(get_bits(gbc, 8));
254
        }
255
1243
        if (get_bits1(gbc))
256
            skip_bits(gbc, 8); //skip language code
257
1243
        if (get_bits1(gbc))
258
551
            skip_bits(gbc, 7); //skip audio production information
259
1243
    } while (i--);
260
261
1243
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
262
263
    /* skip the timecodes or parse the Alternate Bit Stream Syntax */
264
1243
    if (s->bitstream_id != 6) {
265
1079
        if (get_bits1(gbc))
266
            skip_bits(gbc, 14); //skip timecode1
267
1079
        if (get_bits1(gbc))
268
            skip_bits(gbc, 14); //skip timecode2
269
    } else {
270
164
        if (get_bits1(gbc)) {
271
164
            s->preferred_downmix       = get_bits(gbc, 2);
272
164
            s->center_mix_level_ltrt   = get_bits(gbc, 3);
273
164
            s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
274
164
            s->center_mix_level        = get_bits(gbc, 3);
275
164
            s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
276
        }
277
164
        if (get_bits1(gbc)) {
278
162
            s->dolby_surround_ex_mode = get_bits(gbc, 2);
279
162
            s->dolby_headphone_mode   = get_bits(gbc, 2);
280
162
            skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
281
        }
282
    }
283
284
    /* skip additional bitstream info */
285
1243
    if (get_bits1(gbc)) {
286
        i = get_bits(gbc, 6);
287
        do {
288
            skip_bits(gbc, 8);
289
        } while (i--);
290
    }
291
292
1243
    return 0;
293
}
294
295
/**
296
 * Common function to parse AC-3 or E-AC-3 frame header
297
 */
298
2444
static int parse_frame_header(AC3DecodeContext *s)
299
{
300
    AC3HeaderInfo hdr;
301
    int err;
302
303
2444
    err = ff_ac3_parse_header(&s->gbc, &hdr);
304
2444
    if (err)
305
        return err;
306
307
    /* get decoding parameters from header info */
308
2444
    s->bit_alloc_params.sr_code     = hdr.sr_code;
309
2444
    s->bitstream_id                 = hdr.bitstream_id;
310
2444
    s->bitstream_mode               = hdr.bitstream_mode;
311
2444
    s->channel_mode                 = hdr.channel_mode;
312
2444
    s->lfe_on                       = hdr.lfe_on;
313
2444
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
314
2444
    s->sample_rate                  = hdr.sample_rate;
315
2444
    s->bit_rate                     = hdr.bit_rate;
316
2444
    s->channels                     = hdr.channels;
317
2444
    s->fbw_channels                 = s->channels - s->lfe_on;
318
2444
    s->lfe_ch                       = s->fbw_channels + 1;
319
2444
    s->frame_size                   = hdr.frame_size;
320
2444
    s->superframe_size             += hdr.frame_size;
321
2444
    s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
322
2444
    s->center_mix_level             = hdr.center_mix_level;
323
2444
    s->center_mix_level_ltrt        = 4; // -3.0dB
324
2444
    s->surround_mix_level           = hdr.surround_mix_level;
325
2444
    s->surround_mix_level_ltrt      = 4; // -3.0dB
326
2444
    s->lfe_mix_level_exists         = 0;
327
2444
    s->num_blocks                   = hdr.num_blocks;
328
2444
    s->frame_type                   = hdr.frame_type;
329
2444
    s->substreamid                  = hdr.substreamid;
330
2444
    s->dolby_surround_mode          = hdr.dolby_surround_mode;
331
2444
    s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
332
2444
    s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
333
334
2444
    if (s->lfe_on) {
335
594
        s->start_freq[s->lfe_ch]     = 0;
336
594
        s->end_freq[s->lfe_ch]       = 7;
337
594
        s->num_exp_groups[s->lfe_ch] = 2;
338
594
        s->channel_in_cpl[s->lfe_ch] = 0;
339
    }
340
341
2444
    if (s->bitstream_id <= 10) {
342
1243
        s->eac3                  = 0;
343
1243
        s->snr_offset_strategy   = 2;
344
1243
        s->block_switch_syntax   = 1;
345
1243
        s->dither_flag_syntax    = 1;
346
1243
        s->bit_allocation_syntax = 1;
347
1243
        s->fast_gain_syntax      = 0;
348
1243
        s->first_cpl_leak        = 0;
349
1243
        s->dba_syntax            = 1;
350
1243
        s->skip_syntax           = 1;
351
1243
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
352
1243
        return ac3_parse_header(s);
353
    } else if (CONFIG_EAC3_DECODER) {
354
1201
        s->eac3 = 1;
355
1201
        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
417
static int set_downmix_coeffs(AC3DecodeContext *s)
367
{
368
    int i;
369
417
    float cmix = gain_levels[s->  center_mix_level];
370
417
    float smix = gain_levels[s->surround_mix_level];
371
    float norm0, norm1;
372
    float downmix_coeffs[2][AC3_MAX_CHANNELS];
373
374
417
    if (!s->downmix_coeffs[0]) {
375
14
        s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
376
                                               sizeof(**s->downmix_coeffs));
377
14
        if (!s->downmix_coeffs[0])
378
            return AVERROR(ENOMEM);
379
14
        s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
380
    }
381
382
2313
    for (i = 0; i < s->fbw_channels; i++) {
383
1896
        downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
384
1896
        downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
385
    }
386

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

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

417
    if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
394
228
        int nf = s->channel_mode - 4;
395
228
        downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
396
    }
397
398
    /* renormalize */
399
417
    norm0 = norm1 = 0.0;
400
2313
    for (i = 0; i < s->fbw_channels; i++) {
401
1896
        norm0 += downmix_coeffs[0][i];
402
1896
        norm1 += downmix_coeffs[1][i];
403
    }
404
417
    norm0 = 1.0f / norm0;
405
417
    norm1 = 1.0f / norm1;
406
2313
    for (i = 0; i < s->fbw_channels; i++) {
407
1896
        downmix_coeffs[0][i] *= norm0;
408
1896
        downmix_coeffs[1][i] *= norm1;
409
    }
410
411
417
    if (s->output_mode == AC3_CHMODE_MONO) {
412
1314
        for (i = 0; i < s->fbw_channels; i++)
413
1074
            downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
414
1074
                                    downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
415
    }
416
2313
    for (i = 0; i < s->fbw_channels; i++) {
417
1896
        s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
418
1896
        s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
419
    }
420
421
417
    return 0;
422
}
423
424
/**
425
 * Decode the grouped exponents according to exponent strategy.
426
 * reference: Section 7.1.3 Exponent Decoding
427
 */
428
13523
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
13523
    group_size = exp_strategy + (exp_strategy == EXP_D45);
438
483784
    for (grp = 0, i = 0; grp < ngrps; grp++) {
439
470261
        expacc = get_bits(gbc, 7);
440
470261
        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
470261
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
445
470261
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
446
470261
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
447
    }
448
449
    /* convert to absolute exps and expand groups */
450
13523
    prevexp = absexp;
451
1424306
    for (i = 0, j = 0; i < ngrps * 3; i++) {
452
1410783
        prevexp += dexp[i] - 2;
453
1410783
        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

1410783
        switch (group_size) {
458
104523
        case 4: dexps[j++] = prevexp;
459
104523
                dexps[j++] = prevexp;
460
272535
        case 2: dexps[j++] = prevexp;
461
1410783
        case 1: dexps[j++] = prevexp;
462
        }
463
    }
464
13523
    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
7358
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
473
{
474
    int bin, band, ch;
475
476
7358
    bin = s->start_freq[CPL_CH];
477
33412
    for (band = 0; band < s->num_cpl_bands; band++) {
478
26054
        int band_start = bin;
479
26054
        int band_end = bin + s->cpl_band_sizes[band];
480
88350
        for (ch = 1; ch <= s->fbw_channels; ch++) {
481
62296
            if (s->channel_in_cpl[ch]) {
482
62296
                int cpl_coord = s->cpl_coords[ch][band] << 5;
483
1477960
                for (bin = band_start; bin < band_end; bin++) {
484
1415664
                    s->fixed_coeffs[ch][bin] =
485
1415664
                        MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
486
                }
487

62296
                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
26054
        bin = band_end;
494
    }
495
7358
}
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
47864
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
514
{
515
47864
    int start_freq = s->start_freq[ch_index];
516
47864
    int end_freq   = s->end_freq[ch_index];
517
47864
    uint8_t *baps  = s->bap[ch_index];
518
47864
    int8_t *exps   = s->dexps[ch_index];
519
47864
    int32_t *coeffs = s->fixed_coeffs[ch_index];
520

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

6702642
        switch (bap) {
528
2061329
        case 0:
529
            /* random noise with approximate range of -0.707 to 0.707 */
530
2061329
            if (dither)
531
2057022
                mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
532
            else
533
4307
                mantissa = 0;
534
2061329
            break;
535
1384884
        case 1:
536
1384884
            if (m->b1) {
537
919409
                m->b1--;
538
919409
                mantissa = m->b1_mant[m->b1];
539
            } else {
540
465475
                int bits      = get_bits(gbc, 5);
541
465475
                mantissa      = b1_mantissas[bits][0];
542
465475
                m->b1_mant[1] = b1_mantissas[bits][1];
543
465475
                m->b1_mant[0] = b1_mantissas[bits][2];
544
465475
                m->b1         = 2;
545
            }
546
1384884
            break;
547
640013
        case 2:
548
640013
            if (m->b2) {
549
423038
                m->b2--;
550
423038
                mantissa = m->b2_mant[m->b2];
551
            } else {
552
216975
                int bits      = get_bits(gbc, 7);
553
216975
                mantissa      = b2_mantissas[bits][0];
554
216975
                m->b2_mant[1] = b2_mantissas[bits][1];
555
216975
                m->b2_mant[0] = b2_mantissas[bits][2];
556
216975
                m->b2         = 2;
557
            }
558
640013
            break;
559
743329
        case 3:
560
743329
            mantissa = b3_mantissas[get_bits(gbc, 3)];
561
743329
            break;
562
484273
        case 4:
563
484273
            if (m->b4) {
564
239124
                m->b4 = 0;
565
239124
                mantissa = m->b4_mant;
566
            } else {
567
245149
                int bits   = get_bits(gbc, 7);
568
245149
                mantissa   = b4_mantissas[bits][0];
569
245149
                m->b4_mant = b4_mantissas[bits][1];
570
245149
                m->b4      = 1;
571
            }
572
484273
            break;
573
400099
        case 5:
574
400099
            mantissa = b5_mantissas[get_bits(gbc, 4)];
575
400099
            break;
576
988715
        default: /* 6 to 15 */
577
            /* Shift mantissa and sign-extend it. */
578
988715
            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
988715
            mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
583
988715
            break;
584
        }
585
6702642
        coeffs[freq] = mantissa >> exps[freq];
586
    }
587
47864
}
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
14132
static void remove_dithering(AC3DecodeContext *s) {
595
    int ch, i;
596
597
56454
    for (ch = 1; ch <= s->fbw_channels; ch++) {
598

42322
        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
14132
}
606
607
52724
static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
608
                                              int ch, mant_groups *m)
609
{
610
52724
    if (!s->channel_uses_aht[ch]) {
611
47864
        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
4860
        if (CONFIG_EAC3_DECODER && !blk)
617
810
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
618
599292
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
619
594432
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
620
        }
621
    }
622
52724
}
623
624
/**
625
 * Decode the transform coefficients.
626
 */
627
14132
static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
628
{
629
    int ch, end;
630
14132
    int got_cplchan = 0;
631
    mant_groups m;
632
633
14132
    m.b1 = m.b2 = m.b4 = 0;
634
635
59498
    for (ch = 1; ch <= s->channels; ch++) {
636
        /* transform coefficients for full-bandwidth channel */
637
45366
        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
45366
        if (s->channel_in_cpl[ch])  {
641
19792
            if (!got_cplchan) {
642
7358
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
643
7358
                calc_transform_coeffs_cpl(s);
644
7358
                got_cplchan = 1;
645
            }
646
19792
            end = s->end_freq[CPL_CH];
647
        } else {
648
25574
            end = s->end_freq[ch];
649
        }
650
        do
651
3456294
            s->fixed_coeffs[ch][end] = 0;
652
3456294
        while (++end < 256);
653
    }
654
655
    /* zero the dithered coefficients for appropriate channels */
656
14132
    remove_dithering(s);
657
14132
}
658
659
/**
660
 * Stereo rematrixing.
661
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
662
 */
663
8616
static void do_rematrixing(AC3DecodeContext *s)
664
{
665
    int bnd, i;
666
    int end, bndend;
667
668
8616
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
669
670
43068
    for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
671
34452
        if (s->rematrixing_flags[bnd]) {
672
23330
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
673
637874
            for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
674
614544
                int tmp0 = s->fixed_coeffs[1][i];
675
614544
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
676
614544
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
677
            }
678
        }
679
    }
680
8616
}
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
14132
static inline void do_imdct(AC3DecodeContext *s, int channels, int offset)
688
{
689
    int ch;
690
691
50434
    for (ch = 1; ch <= channels; ch++) {
692
36302
        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
36296
            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
33373
            s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
715
33373
                                       s->tmp_output, s->window, 128);
716
#endif
717
36296
            memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample));
718
        }
719
    }
720
14132
}
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
1766
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
1766
    int subbnd, bnd, n_subbands, n_bands=0;
774
    uint8_t bnd_sz[22];
775
776
1766
    n_subbands = end_subband - start_subband;
777
778
1766
    if (!blk)
779
1766
        memcpy(band_struct, default_band_struct, band_struct_size);
780
781
1766
    av_assert0(band_struct_size >= start_subband + n_subbands);
782
783
1766
    band_struct += start_subband + 1;
784
785
    /* decode band structure from bitstream or use default */
786

1766
    if (!eac3 || get_bits1(gbc)) {
787
6440
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
788
5079
            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

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

7223
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
800
7223
            if (band_struct[subbnd - 1]) {
801
3422
                n_bands--;
802
3422
                bnd_sz[bnd] += subbnd_size;
803
            } else {
804
3801
                bnd_sz[++bnd] = subbnd_size;
805
            }
806
        }
807
    }
808
809
    /* set optional output params */
810
1766
    if (num_bands)
811
1766
        *num_bands = n_bands;
812
1766
    if (band_sizes)
813
1766
        memcpy(band_sizes, bnd_sz, n_bands);
814
1766
}
815
816
539
static inline int spx_strategy(AC3DecodeContext *s, int blk)
817
{
818
539
    GetBitContext *bc = &s->gbc;
819
539
    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
539
    if (s->channel_mode == AC3_CHMODE_MONO) {
825
        s->channel_uses_spx[1] = 1;
826
    } else {
827
1761
        for (ch = 1; ch <= fbw_channels; ch++)
828
1222
            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
539
    dst_start_freq = get_bits(bc, 2);
834
539
    start_subband  = get_bits(bc, 3) + 2;
835
539
    if (start_subband > 7)
836
491
        start_subband += start_subband - 7;
837
539
    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
539
    if (end_subband   > 7)
842
539
        end_subband   += end_subband   - 7;
843
539
    dst_start_freq = dst_start_freq * 12 + 25;
844
539
    src_start_freq = start_subband  * 12 + 25;
845
539
    dst_end_freq   = end_subband    * 12 + 25;
846
847
    /* check validity of spx ranges */
848
539
    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
539
    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
539
    s->spx_dst_start_freq = dst_start_freq;
860
539
    s->spx_src_start_freq = src_start_freq;
861
    if (!USE_FIXED)
862
539
        s->spx_dst_end_freq   = dst_end_freq;
863
864
539
    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
539
                          s->spx_band_sizes,
869
539
                          s->spx_band_struct, sizeof(s->spx_band_struct));
870
539
    return 0;
871
}
872
873
3234
static inline void spx_coordinates(AC3DecodeContext *s)
874
{
875
3234
    GetBitContext *bc = &s->gbc;
876
3234
    int fbw_channels = s->fbw_channels;
877
    int ch, bnd;
878
879
10566
    for (ch = 1; ch <= fbw_channels; ch++) {
880
7332
        if (s->channel_uses_spx[ch]) {
881

7332
            if (s->first_spx_coords[ch] || get_bits1(bc)) {
882
                INTFLOAT spx_blend;
883
                int bin, master_spx_coord;
884
885
1961
                s->first_spx_coords[ch] = 0;
886
1961
                spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
887
1961
                master_spx_coord = get_bits(bc, 2) * 3;
888
889
1961
                bin = s->spx_src_start_freq;
890
6882
                for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
891
4921
                    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
4921
                    nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
918
4921
                    nratio = av_clipf(nratio, 0.0f, 1.0f);
919
4921
                    nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
920
                                                   // to give unity variance
921
4921
                    sblend = sqrtf(1.0f - nratio);
922
#endif
923
4921
                    bin += bandsize;
924
925
                    /* decode spx coordinates */
926
4921
                    spx_coord_exp  = get_bits(bc, 4);
927
4921
                    spx_coord_mant = get_bits(bc, 2);
928
4921
                    if (spx_coord_exp == 15) spx_coord_mant <<= 1;
929
4203
                    else                     spx_coord_mant += 4;
930
4921
                    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
4921
                    spx_coord = spx_coord_mant * (1.0f / (1 << 23));
940
4921
                    s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
941
4921
                    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
3234
}
950
951
2439
static inline int coupling_strategy(AC3DecodeContext *s, int blk,
952
                                    uint8_t *bit_alloc_stages)
953
{
954
2439
    GetBitContext *bc = &s->gbc;
955
2439
    int fbw_channels = s->fbw_channels;
956
2439
    int channel_mode = s->channel_mode;
957
    int ch;
958
959
2439
    memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
960
2439
    if (!s->eac3)
961
1238
        s->cpl_in_use[blk] = get_bits1(bc);
962
2439
    if (s->cpl_in_use[blk]) {
963
        /* coupling in use */
964
        int cpl_start_subband, cpl_end_subband;
965
966
1227
        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

1227
        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

1227
        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
3312
            for (ch = 1; ch <= fbw_channels; ch++)
984
2490
                s->channel_in_cpl[ch] = get_bits1(bc);
985
        }
986
987
        /* phase flags in use */
988
1227
        if (channel_mode == AC3_CHMODE_STEREO)
989
945
            s->phase_flags_in_use = get_bits1(bc);
990
991
        /* coupling frequency range */
992
1227
        cpl_start_subband = get_bits(bc, 4);
993
1227
        cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
994
1227
                                          get_bits(bc, 4) + 3;
995
1227
        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
1227
        s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1001
1227
        s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1002
1003
1227
        decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1004
                              cpl_end_subband,
1005
                              ff_eac3_default_cpl_band_struct,
1006
1227
                              &s->num_cpl_bands, s->cpl_band_sizes,
1007
1227
                              s->cpl_band_struct, sizeof(s->cpl_band_struct));
1008
    } else {
1009
        /* coupling not in use */
1010
5378
        for (ch = 1; ch <= fbw_channels; ch++) {
1011
4166
            s->channel_in_cpl[ch] = 0;
1012
4166
            s->first_cpl_coords[ch] = 1;
1013
        }
1014
1212
        s->first_cpl_leak = s->eac3;
1015
1212
        s->phase_flags_in_use = 0;
1016
    }
1017
1018
2439
    return 0;
1019
}
1020
1021
7358
static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1022
{
1023
7358
    GetBitContext *bc = &s->gbc;
1024
7358
    int fbw_channels = s->fbw_channels;
1025
    int ch, bnd;
1026
7358
    int cpl_coords_exist = 0;
1027
1028
27150
    for (ch = 1; ch <= fbw_channels; ch++) {
1029
19792
        if (s->channel_in_cpl[ch]) {
1030

25659
            if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1031
                int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1032
5867
                s->first_cpl_coords[ch] = 0;
1033
5867
                cpl_coords_exist = 1;
1034
5867
                master_cpl_coord = 3 * get_bits(bc, 2);
1035
21453
                for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1036
15586
                    cpl_coord_exp  = get_bits(bc, 4);
1037
15586
                    cpl_coord_mant = get_bits(bc, 4);
1038
15586
                    if (cpl_coord_exp == 15)
1039
2586
                        s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1040
                    else
1041
13000
                        s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1042
15586
                    s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1043
                }
1044
13925
            } 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

7358
    if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1056
4874
        for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1057
3899
            s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1058
        }
1059
    }
1060
1061
7358
    return 0;
1062
}
1063
1064
/**
1065
 * Decode a single audio block from the AC-3 bitstream.
1066
 */
1067
14132
static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1068
{
1069
14132
    int fbw_channels = s->fbw_channels;
1070
14132
    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
14132
    GetBitContext *gbc = &s->gbc;
1076
14132
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1077
1078
    /* block switch flags */
1079
14132
    different_transforms = 0;
1080
14132
    if (s->block_switch_syntax) {
1081
33240
        for (ch = 1; ch <= fbw_channels; ch++) {
1082
25824
            s->block_switch[ch] = get_bits1(gbc);
1083

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

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

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

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

14132
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1134
2439
        if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1135
            return ret;
1136
11693
    } else if (!s->eac3) {
1137
6178
        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
6178
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1143
        }
1144
    }
1145
14132
    cpl_in_use = s->cpl_in_use[blk];
1146
1147
    /* coupling coordinates */
1148
14132
    if (cpl_in_use) {
1149
7358
        if ((ret = coupling_coordinates(s, blk)) < 0)
1150
            return ret;
1151
    }
1152
1153
    /* stereo rematrixing strategy and band structure */
1154
14132
    if (channel_mode == AC3_CHMODE_STEREO) {
1155

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

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

2843
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1160
                s->num_rematrixing_bands--;
1161
            }
1162
14218
            for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1163
11374
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1164
5772
        } 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
66856
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1173
52724
        if (!s->eac3)
1174
33410
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1175
52724
        if (s->exp_strategy[blk][ch] != EXP_REUSE)
1176
13523
            bit_alloc_stages[ch] = 3;
1177
    }
1178
1179
    /* channel bandwidth */
1180
56454
    for (ch = 1; ch <= fbw_channels; ch++) {
1181
42322
        s->start_freq[ch] = 0;
1182
42322
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1183
            int group_size;
1184
10488
            int prev = s->end_freq[ch];
1185
10488
            if (s->channel_in_cpl[ch])
1186
4135
                s->end_freq[ch] = s->start_freq[CPL_CH];
1187
6353
            else if (s->channel_uses_spx[ch])
1188
1961
                s->end_freq[ch] = s->spx_src_start_freq;
1189
            else {
1190
4392
                int bandwidth_code = get_bits(gbc, 6);
1191
4392
                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
4392
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1196
            }
1197
10488
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1198
10488
            s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1199

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

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

13523
            if (ch != CPL_CH && ch != s->lfe_ch)
1218
10488
                skip_bits(gbc, 2); /* skip gainrng */
1219
        }
1220
    }
1221
1222
    /* bit allocation information */
1223
14132
    if (s->bit_allocation_syntax) {
1224
8642
        if (get_bits1(gbc)) {
1225
1556
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1226
1556
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1227
1556
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1228
1556
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1229
1556
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1230
8548
            for (ch = !cpl_in_use; ch <= s->channels; ch++)
1231
6992
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1232
7086
        } 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

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

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

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

5569
                if (blk && s->snr_offset[ch] != snr) {
1251
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1252
                }
1253
5569
                s->snr_offset[ch] = snr;
1254
1255
                /* fast gain (normal AC-3 only) */
1256
5569
                if (!s->eac3) {
1257
5569
                    int prev = s->fast_gain[ch];
1258
5569
                    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

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

7381
        } 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

14132
    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

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

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

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

1273
            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
1273
            s->bit_alloc_params.cpl_fast_leak = fl;
1301
1273
            s->bit_alloc_params.cpl_slow_leak = sl;
1302

6085
        } 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
7358
        s->first_cpl_leak = 0;
1308
    }
1309
1310
    /* delta bit allocation information */
1311

14132
    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
14132
    } else if (blk == 0) {
1335
12925
        for (ch = 0; ch <= s->channels; ch++) {
1336
10488
            s->dba_mode[ch] = DBA_NONE;
1337
        }
1338
    }
1339
1340
    /* Bit allocation */
1341
66856
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1342
52724
        if (bit_alloc_stages[ch] > 2) {
1343
            /* Exponent mapping into PSD and PSD integration */
1344
13523
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1345
                                      s->start_freq[ch], s->end_freq[ch],
1346
13523
                                      s->psd[ch], s->band_psd[ch]);
1347
        }
1348
52724
        if (bit_alloc_stages[ch] > 1) {
1349
            /* Compute excitation function, Compute masking curve, and
1350
               Apply delta bit allocation */
1351
13665
            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
13665
                                           s->fast_gain[ch],   (ch == s->lfe_ch),
1354
                                           s->dba_mode[ch],    s->dba_nsegs[ch],
1355
13665
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1356
13665
                                           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
52724
        if (bit_alloc_stages[ch] > 0) {
1362
            /* Compute bit allocation */
1363
27330
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1364
13665
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1365
13665
            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
13665
                                      bap_tab, s->bap[ch]);
1370
        }
1371
    }
1372
1373
    /* unused dummy data */
1374

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

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

45366
        if (s->heavy_compression && s->compression_exists[audio_channel])
1396
            gain = s->heavy_dynamic_range[audio_channel];
1397
        else
1398
45366
            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
38358
        if (s->target_level != 0)
1404
          gain = gain * s->level_gain[audio_channel];
1405
38358
        gain *= 1.0 / 4194304.0f;
1406
38358
        s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1407
38358
                                               s->fixed_coeffs[ch], gain, 256);
1408
#endif
1409
    }
1410
1411
    /* apply spectral extension to high frequency bins */
1412
14132
    if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1413
3234
        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
16610
    downmix_output = s->channels != s->out_channels &&
1420
2478
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1421
                     s->fbw_channels == s->out_channels);
1422
14132
    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
14126
        if (downmix_output) {
1443
2475
            AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1444
                                          s->out_channels, s->fbw_channels, 256);
1445
        }
1446
1447

14126
        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
14126
        do_imdct(s, s->out_channels, offset);
1454
    }
1455
1456
14132
    return 0;
1457
}
1458
1459
/**
1460
 * Decode a single AC-3 frame.
1461
 */
1462
2286
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1463
                            int *got_frame_ptr, AVPacket *avpkt)
1464
{
1465
2286
    AVFrame *frame     = data;
1466
2286
    const uint8_t *buf = avpkt->data;
1467
2286
    int buf_size, full_buf_size = avpkt->size;
1468
2286
    AC3DecodeContext *s = avctx->priv_data;
1469
    int blk, ch, err, offset, ret;
1470
    int i;
1471
2286
    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
2286
    s->superframe_size = 0;
1479
1480
2286
    buf_size = full_buf_size;
1481
2462
    for (i = 1; i < buf_size; i += 2) {
1482

2461
        if (buf[i] == 0x77 || buf[i] == 0x0B) {
1483
2286
            if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1484
2285
                i--;
1485
2285
                break;
1486
1
            } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1487
                break;
1488
            }
1489
        }
1490
    }
1491
2286
    if (i >= buf_size)
1492
1
        return AVERROR_INVALIDDATA;
1493
2285
    if (i > 10)
1494
        return i;
1495
2285
    buf += i;
1496
2285
    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

2285
    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
2285
        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
2285
    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
2285
    buf = s->input_buffer;
1515
2444
dependent_frame:
1516
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1517
2444
    if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1518
        return ret;
1519
1520
    /* parse the syncinfo */
1521
2444
    err = parse_frame_header(s);
1522
1523
2444
    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
2444
        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
2437
        } 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

2444
    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

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

2441
        if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1602
                s->fbw_channels == s->out_channels)) {
1603
417
            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
2444
    avctx->channels = s->out_channels;
1613
2444
    avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1614
2444
    if (s->output_mode & AC3_OUTPUT_LFEON)
1615
366
        avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1616
1617
    /* set audio service type based on bitstream mode for AC-3 */
1618
2444
    avctx->audio_service_type = s->bitstream_mode;
1619

2444
    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
2444
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1624
2444
    offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1625
19552
    for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1626
17108
        output[ch] = s->output[ch + offset];
1627
17108
        s->outptr[ch] = s->output[ch + offset];
1628
    }
1629
10529
    for (ch = 0; ch < s->channels; ch++) {
1630
8085
        if (ch < s->out_channels)
1631
6555
            s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1632
    }
1633
16618
    for (blk = 0; blk < s->num_blocks; blk++) {
1634

14174
        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
14174
        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
50564
        for (ch = 0; ch < s->out_channels; ch++)
1642
36390
            output[ch] = s->outptr[channel_map[ch]];
1643
50564
        for (ch = 0; ch < s->out_channels; ch++) {
1644

36390
            if (!ch || channel_map[ch])
1645
36390
                s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1646
        }
1647
    }
1648
1649
    /* keep last block for error concealment in next frame */
1650
8999
    for (ch = 0; ch < s->out_channels; ch++)
1651
6555
        memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1652
1653
    /* check if there is dependent frame */
1654
2444
    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
2285
skip:
1684
1685
2285
    frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
1686
1687
    /* if frame is ok, set audio parameters */
1688
2285
    if (!err) {
1689
2278
        avctx->sample_rate = s->sample_rate;
1690
2278
        avctx->bit_rate    = s->bit_rate + s->prev_bit_rate;
1691
    }
1692
1693
38845
    for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1694
36560
        extended_channel_map[ch] = ch;
1695
1696
2285
    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
2285
    frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1753
2285
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1754
        return ret;
1755
1756
8522
    for (ch = 0; ch < avctx->channels; ch++) {
1757
6237
        int map = extended_channel_map[ch];
1758

6237
        av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
1759
6237
        memcpy((SHORTFLOAT *)frame->extended_data[ch],
1760
6237
               s->output_buffer[map],
1761
6237
               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
2285
    matrix_encoding = AV_MATRIX_ENCODING_NONE;
1771
2285
    if (s->channel_mode == AC3_CHMODE_STEREO &&
1772
1438
        s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1773
1438
        if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1774
491
            matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1775
947
        else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1776
            matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1777
847
    } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1778
435
               s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1779
207
        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
207
        default: // not indicated or off
1787
207
            break;
1788
        }
1789
640
    }
1790
2285
    if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1791
        return ret;
1792
1793
    /* AVDownmixInfo */
1794
2285
    if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1795

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