GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mlpdec.c Lines: 446 623 71.6 %
Date: 2019-11-20 04:07:19 Branches: 252 403 62.5 %

Line Branch Exec Source
1
/*
2
 * MLP decoder
3
 * Copyright (c) 2007-2008 Ian Caulfield
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/**
23
 * @file
24
 * MLP decoder
25
 */
26
27
#include <stdint.h>
28
29
#include "avcodec.h"
30
#include "libavutil/internal.h"
31
#include "libavutil/intreadwrite.h"
32
#include "libavutil/channel_layout.h"
33
#include "get_bits.h"
34
#include "internal.h"
35
#include "libavutil/crc.h"
36
#include "parser.h"
37
#include "mlp_parse.h"
38
#include "mlpdsp.h"
39
#include "mlp.h"
40
#include "config.h"
41
42
/** number of bits used for VLC lookup - longest Huffman code is 9 */
43
#if ARCH_ARM
44
#define VLC_BITS            5
45
#define VLC_STATIC_SIZE     64
46
#else
47
#define VLC_BITS            9
48
#define VLC_STATIC_SIZE     512
49
#endif
50
51
typedef struct SubStream {
52
    /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
53
    uint8_t     restart_seen;
54
55
    //@{
56
    /** restart header data */
57
    /// The type of noise to be used in the rematrix stage.
58
    uint16_t    noise_type;
59
60
    /// The index of the first channel coded in this substream.
61
    uint8_t     min_channel;
62
    /// The index of the last channel coded in this substream.
63
    uint8_t     max_channel;
64
    /// The number of channels input into the rematrix stage.
65
    uint8_t     max_matrix_channel;
66
    /// For each channel output by the matrix, the output channel to map it to
67
    uint8_t     ch_assign[MAX_CHANNELS];
68
    /// The channel layout for this substream
69
    uint64_t    mask;
70
    /// The matrix encoding mode for this substream
71
    enum AVMatrixEncoding matrix_encoding;
72
73
    /// Channel coding parameters for channels in the substream
74
    ChannelParams channel_params[MAX_CHANNELS];
75
76
    /// The left shift applied to random noise in 0x31ea substreams.
77
    uint8_t     noise_shift;
78
    /// The current seed value for the pseudorandom noise generator(s).
79
    uint32_t    noisegen_seed;
80
81
    /// Set if the substream contains extra info to check the size of VLC blocks.
82
    uint8_t     data_check_present;
83
84
    /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
85
    uint8_t     param_presence_flags;
86
#define PARAM_BLOCKSIZE     (1 << 7)
87
#define PARAM_MATRIX        (1 << 6)
88
#define PARAM_OUTSHIFT      (1 << 5)
89
#define PARAM_QUANTSTEP     (1 << 4)
90
#define PARAM_FIR           (1 << 3)
91
#define PARAM_IIR           (1 << 2)
92
#define PARAM_HUFFOFFSET    (1 << 1)
93
#define PARAM_PRESENCE      (1 << 0)
94
    //@}
95
96
    //@{
97
    /** matrix data */
98
99
    /// Number of matrices to be applied.
100
    uint8_t     num_primitive_matrices;
101
102
    /// matrix output channel
103
    uint8_t     matrix_out_ch[MAX_MATRICES];
104
105
    /// Whether the LSBs of the matrix output are encoded in the bitstream.
106
    uint8_t     lsb_bypass[MAX_MATRICES];
107
    /// Matrix coefficients, stored as 2.14 fixed point.
108
    DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS];
109
    /// Left shift to apply to noise values in 0x31eb substreams.
110
    uint8_t     matrix_noise_shift[MAX_MATRICES];
111
    //@}
112
113
    /// Left shift to apply to Huffman-decoded residuals.
114
    uint8_t     quant_step_size[MAX_CHANNELS];
115
116
    /// number of PCM samples in current audio block
117
    uint16_t    blocksize;
118
    /// Number of PCM samples decoded so far in this frame.
119
    uint16_t    blockpos;
120
121
    /// Left shift to apply to decoded PCM values to get final 24-bit output.
122
    int8_t      output_shift[MAX_CHANNELS];
123
124
    /// Running XOR of all output samples.
125
    int32_t     lossless_check_data;
126
127
} SubStream;
128
129
typedef struct MLPDecodeContext {
130
    AVCodecContext *avctx;
131
132
    /// Current access unit being read has a major sync.
133
    int         is_major_sync_unit;
134
135
    /// Size of the major sync unit, in bytes
136
    int         major_sync_header_size;
137
138
    /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
139
    uint8_t     params_valid;
140
141
    /// Number of substreams contained within this stream.
142
    uint8_t     num_substreams;
143
144
    /// Index of the last substream to decode - further substreams are skipped.
145
    uint8_t     max_decoded_substream;
146
147
    /// Stream needs channel reordering to comply with FFmpeg's channel order
148
    uint8_t     needs_reordering;
149
150
    /// number of PCM samples contained in each frame
151
    int         access_unit_size;
152
    /// next power of two above the number of samples in each frame
153
    int         access_unit_size_pow2;
154
155
    SubStream   substream[MAX_SUBSTREAMS];
156
157
    int         matrix_changed;
158
    int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
159
160
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
161
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
162
    DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];
163
164
    MLPDSPContext dsp;
165
} MLPDecodeContext;
166
167
static const uint64_t thd_channel_order[] = {
168
    AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT,                     // LR
169
    AV_CH_FRONT_CENTER,                                      // C
170
    AV_CH_LOW_FREQUENCY,                                     // LFE
171
    AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT,                       // LRs
172
    AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT,             // LRvh
173
    AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
174
    AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT,                       // LRrs
175
    AV_CH_BACK_CENTER,                                       // Cs
176
    AV_CH_TOP_CENTER,                                        // Ts
177
    AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
178
    AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT,                       // LRw
179
    AV_CH_TOP_FRONT_CENTER,                                  // Cvh
180
    AV_CH_LOW_FREQUENCY_2,                                   // LFE2
181
};
182
183
1757
static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
184
{
185

1757
    return channel_layout && ((channel_layout & mask) == channel_layout);
186
}
187
188
2140
static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
189
                                                   int index)
190
{
191
    int i;
192
193
2140
    if (av_get_channel_layout_nb_channels(channel_layout) <= index)
194
        return 0;
195
196
5778
    for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
197

5778
        if (channel_layout & thd_channel_order[i] && !index--)
198
2140
            return thd_channel_order[i];
199
    return 0;
200
}
201
202
static VLC huff_vlc[3];
203
204
/** Initialize static data, constant between all invocations of the codec. */
205
206
6
static av_cold void init_static(void)
207
{
208
6
    if (!huff_vlc[0].bits) {
209
3
        INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
210
                    &ff_mlp_huffman_tables[0][0][1], 2, 1,
211
                    &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
212
3
        INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
213
                    &ff_mlp_huffman_tables[1][0][1], 2, 1,
214
                    &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
215
3
        INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
216
                    &ff_mlp_huffman_tables[2][0][1], 2, 1,
217
                    &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
218
    }
219
220
6
    ff_mlp_init_crc();
221
6
}
222
223
12178
static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
224
                                          unsigned int substr, unsigned int ch)
225
{
226
12178
    SubStream *s = &m->substream[substr];
227
12178
    ChannelParams *cp = &s->channel_params[ch];
228
12178
    int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
229
12178
    int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
230
12178
    int32_t sign_huff_offset = cp->huff_offset;
231
232
12178
    if (cp->codebook > 0)
233
9059
        sign_huff_offset -= 7 << lsb_bits;
234
235
12178
    if (sign_shift >= 0)
236
11461
        sign_huff_offset -= 1 << sign_shift;
237
238
12178
    return sign_huff_offset;
239
}
240
241
/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
242
 *  and plain LSBs. */
243
244
767880
static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
245
                                     unsigned int substr, unsigned int pos)
246
{
247
767880
    SubStream *s = &m->substream[substr];
248
    unsigned int mat, channel;
249
250
1990960
    for (mat = 0; mat < s->num_primitive_matrices; mat++)
251
1223080
        if (s->lsb_bypass[mat])
252
            m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
253
254
2576440
    for (channel = s->min_channel; channel <= s->max_channel; channel++) {
255
1808560
        ChannelParams *cp = &s->channel_params[channel];
256
1808560
        int codebook = cp->codebook;
257
1808560
        int quant_step_size = s->quant_step_size[channel];
258
1808560
        int lsb_bits = cp->huff_lsbs - quant_step_size;
259
1808560
        int result = 0;
260
261
1808560
        if (codebook > 0)
262
1703520
            result = get_vlc2(gbp, huff_vlc[codebook-1].table,
263
                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
264
265
1808560
        if (result < 0)
266
            return AVERROR_INVALIDDATA;
267
268
1808560
        if (lsb_bits > 0)
269
1751336
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
270
271
1808560
        result  += cp->sign_huff_offset;
272
1808560
        result *= 1 << quant_step_size;
273
274
1808560
        m->sample_buffer[pos + s->blockpos][channel] = result;
275
    }
276
277
767880
    return 0;
278
}
279
280
6
static av_cold int mlp_decode_init(AVCodecContext *avctx)
281
{
282
6
    MLPDecodeContext *m = avctx->priv_data;
283
    int substr;
284
285
6
    init_static();
286
6
    m->avctx = avctx;
287
30
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
288
24
        m->substream[substr].lossless_check_data = 0xffffffff;
289
6
    ff_mlpdsp_init(&m->dsp);
290
291
6
    return 0;
292
}
293
294
/** Read a major sync info header - contains high level information about
295
 *  the stream - sample rate, channel arrangement etc. Most of this
296
 *  information is not actually necessary for decoding, only for playback.
297
 */
298
299
1543
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
300
{
301
    MLPHeaderInfo mh;
302
    int substr, ret;
303
304
1543
    if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
305
        return ret;
306
307
1543
    if (mh.group1_bits == 0) {
308
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
309
        return AVERROR_INVALIDDATA;
310
    }
311
1543
    if (mh.group2_bits > mh.group1_bits) {
312
        av_log(m->avctx, AV_LOG_ERROR,
313
               "Channel group 2 cannot have more bits per sample than group 1.\n");
314
        return AVERROR_INVALIDDATA;
315
    }
316
317

1543
    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
318
        av_log(m->avctx, AV_LOG_ERROR,
319
               "Channel groups with differing sample rates are not currently supported.\n");
320
        return AVERROR_INVALIDDATA;
321
    }
322
323
1543
    if (mh.group1_samplerate == 0) {
324
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
325
        return AVERROR_INVALIDDATA;
326
    }
327
1543
    if (mh.group1_samplerate > MAX_SAMPLERATE) {
328
        av_log(m->avctx, AV_LOG_ERROR,
329
               "Sampling rate %d is greater than the supported maximum (%d).\n",
330
               mh.group1_samplerate, MAX_SAMPLERATE);
331
        return AVERROR_INVALIDDATA;
332
    }
333
1543
    if (mh.access_unit_size > MAX_BLOCKSIZE) {
334
        av_log(m->avctx, AV_LOG_ERROR,
335
               "Block size %d is greater than the supported maximum (%d).\n",
336
               mh.access_unit_size, MAX_BLOCKSIZE);
337
        return AVERROR_INVALIDDATA;
338
    }
339
1543
    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
340
        av_log(m->avctx, AV_LOG_ERROR,
341
               "Block size pow2 %d is greater than the supported maximum (%d).\n",
342
               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
343
        return AVERROR_INVALIDDATA;
344
    }
345
346
1543
    if (mh.num_substreams == 0)
347
        return AVERROR_INVALIDDATA;
348

1543
    if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
349
        av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
350
        return AVERROR_INVALIDDATA;
351
    }
352
1543
    if (mh.num_substreams > MAX_SUBSTREAMS) {
353
        avpriv_request_sample(m->avctx,
354
                              "%d substreams (more than the "
355
                              "maximum supported by the decoder)",
356
                              mh.num_substreams);
357
        return AVERROR_PATCHWELCOME;
358
    }
359
360
1543
    m->major_sync_header_size = mh.header_size;
361
362
1543
    m->access_unit_size      = mh.access_unit_size;
363
1543
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;
364
365
1543
    m->num_substreams        = mh.num_substreams;
366
367
    /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
368
1543
    m->max_decoded_substream = FFMIN(m->num_substreams - 1, 2);
369
370
1543
    m->avctx->sample_rate    = mh.group1_samplerate;
371
1543
    m->avctx->frame_size     = mh.access_unit_size;
372
373
1543
    m->avctx->bits_per_raw_sample = mh.group1_bits;
374
1543
    if (mh.group1_bits > 16)
375
428
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
376
    else
377
1115
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
378
3086
    m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign,
379
1543
                                                           m->substream[m->max_decoded_substream].output_shift,
380
1543
                                                           m->substream[m->max_decoded_substream].max_matrix_channel,
381
1543
                                                           m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
382
383
1543
    m->params_valid = 1;
384
7715
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
385
6172
        m->substream[substr].restart_seen = 0;
386
387
    /* Set the layout for each substream. When there's more than one, the first
388
     * substream is Stereo. Subsequent substreams' layouts are indicated in the
389
     * major sync. */
390
1543
    if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
391
1115
        if (mh.stream_type != 0xbb) {
392
            avpriv_request_sample(m->avctx,
393
                        "unexpected stream_type %X in MLP",
394
                        mh.stream_type);
395
            return AVERROR_PATCHWELCOME;
396
        }
397
1115
        if ((substr = (mh.num_substreams > 1)))
398
            m->substream[0].mask = AV_CH_LAYOUT_STEREO;
399
1115
        m->substream[substr].mask = mh.channel_layout_mlp;
400
    } else {
401
428
        if (mh.stream_type != 0xba) {
402
            avpriv_request_sample(m->avctx,
403
                        "unexpected stream_type %X in !MLP",
404
                        mh.stream_type);
405
            return AVERROR_PATCHWELCOME;
406
        }
407
428
        if ((substr = (mh.num_substreams > 1)))
408
428
            m->substream[0].mask = AV_CH_LAYOUT_STEREO;
409
428
        if (mh.num_substreams > 2)
410
            if (mh.channel_layout_thd_stream2)
411
                m->substream[2].mask = mh.channel_layout_thd_stream2;
412
            else
413
                m->substream[2].mask = mh.channel_layout_thd_stream1;
414
428
        m->substream[substr].mask = mh.channel_layout_thd_stream1;
415
416

428
        if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
417
            av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
418
            m->max_decoded_substream = 0;
419
            if (m->avctx->channels==2)
420
                m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
421
        }
422
    }
423
424

1543
    m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
425
426
    /* Parse the TrueHD decoder channel modifiers and set each substream's
427
     * AVMatrixEncoding accordingly.
428
     *
429
     * The meaning of the modifiers depends on the channel layout:
430
     *
431
     * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
432
     *
433
     * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
434
     *
435
     * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
436
     *   layouts with an Ls/Rs channel pair
437
     */
438
7715
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
439
6172
        m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
440
1543
    if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
441
428
        if (mh.num_substreams > 2 &&
442
            mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
443
            mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
444
            mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
445
            m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
446
447
428
        if (mh.num_substreams > 1 &&
448
428
            mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
449
428
            mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
450
428
            mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
451
            m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
452
453
428
        if (mh.num_substreams > 0)
454
428
            switch (mh.channel_modifier_thd_stream0) {
455
            case THD_CH_MODIFIER_LTRT:
456
                m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
457
                break;
458
            case THD_CH_MODIFIER_LBINRBIN:
459
                m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
460
                break;
461
428
            default:
462
428
                break;
463
            }
464
1115
    }
465
466
1543
    return 0;
467
}
468
469
/** Read a restart header from a block in a substream. This contains parameters
470
 *  required to decode the audio that do not change very often. Generally
471
 *  (always) present only in blocks following a major sync. */
472
473
1757
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
474
                               const uint8_t *buf, unsigned int substr)
475
{
476
1757
    SubStream *s = &m->substream[substr];
477
    unsigned int ch;
478
    int sync_word, tmp;
479
    uint8_t checksum;
480
    uint8_t lossless_check;
481
1757
    int start_count = get_bits_count(gbp);
482
    int min_channel, max_channel, max_matrix_channel, noise_type;
483
3514
    const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
484
                                     ? MAX_MATRIX_CHANNEL_MLP
485
1757
                                     : MAX_MATRIX_CHANNEL_TRUEHD;
486
487
1757
    sync_word = get_bits(gbp, 13);
488
489
1757
    if (sync_word != 0x31ea >> 1) {
490
        av_log(m->avctx, AV_LOG_ERROR,
491
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
492
        return AVERROR_INVALIDDATA;
493
    }
494
495
1757
    noise_type = get_bits1(gbp);
496
497

1757
    if (m->avctx->codec_id == AV_CODEC_ID_MLP && noise_type) {
498
        av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
499
        return AVERROR_INVALIDDATA;
500
    }
501
502
1757
    skip_bits(gbp, 16); /* Output timestamp */
503
504
1757
    min_channel        = get_bits(gbp, 4);
505
1757
    max_channel        = get_bits(gbp, 4);
506
1757
    max_matrix_channel = get_bits(gbp, 4);
507
508
1757
    if (max_matrix_channel > std_max_matrix_channel) {
509
        av_log(m->avctx, AV_LOG_ERROR,
510
               "Max matrix channel cannot be greater than %d.\n",
511
               std_max_matrix_channel);
512
        return AVERROR_INVALIDDATA;
513
    }
514
515
1757
    if (max_channel != max_matrix_channel) {
516
        av_log(m->avctx, AV_LOG_ERROR,
517
               "Max channel must be equal max matrix channel.\n");
518
        return AVERROR_INVALIDDATA;
519
    }
520
521
    /* This should happen for TrueHD streams with >6 channels and MLP's noise
522
     * type. It is not yet known if this is allowed. */
523

1757
    if (max_channel > MAX_MATRIX_CHANNEL_MLP && !noise_type) {
524
        avpriv_request_sample(m->avctx,
525
                              "%d channels (more than the "
526
                              "maximum supported by the decoder)",
527
                              max_channel + 2);
528
        return AVERROR_PATCHWELCOME;
529
    }
530
531
1757
    if (min_channel > max_channel) {
532
        av_log(m->avctx, AV_LOG_ERROR,
533
               "Substream min channel cannot be greater than max channel.\n");
534
        return AVERROR_INVALIDDATA;
535
    }
536
537
1757
    s->min_channel        = min_channel;
538
1757
    s->max_channel        = max_channel;
539
1757
    s->max_matrix_channel = max_matrix_channel;
540
1757
    s->noise_type         = noise_type;
541
542
1757
    if (mlp_channel_layout_subset(m->avctx->request_channel_layout, s->mask) &&
543
214
        m->max_decoded_substream > substr) {
544
214
        av_log(m->avctx, AV_LOG_DEBUG,
545
               "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
546
               "Further substreams will be skipped.\n",
547
214
               s->max_channel + 1, s->mask, substr);
548
214
        m->max_decoded_substream = substr;
549
    }
550
551
1757
    s->noise_shift   = get_bits(gbp,  4);
552
1757
    s->noisegen_seed = get_bits(gbp, 23);
553
554
1757
    skip_bits(gbp, 19);
555
556
1757
    s->data_check_present = get_bits1(gbp);
557
1757
    lossless_check = get_bits(gbp, 8);
558
1757
    if (substr == m->max_decoded_substream
559
1543
        && s->lossless_check_data != 0xffffffff) {
560
1540
        tmp = xor_32_to_8(s->lossless_check_data);
561
1540
        if (tmp != lossless_check)
562
            av_log(m->avctx, AV_LOG_WARNING,
563
                   "Lossless check failed - expected %02x, calculated %02x.\n",
564
                   lossless_check, tmp);
565
    }
566
567
1757
    skip_bits(gbp, 16);
568
569
1757
    memset(s->ch_assign, 0, sizeof(s->ch_assign));
570
571
6127
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
572
4370
        int ch_assign = get_bits(gbp, 6);
573
4370
        if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
574
2140
            uint64_t channel = thd_channel_layout_extract_channel(s->mask,
575
                                                                  ch_assign);
576
2140
            ch_assign = av_get_channel_layout_channel_index(s->mask,
577
                                                            channel);
578
        }
579

4370
        if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
580
            avpriv_request_sample(m->avctx,
581
                                  "Assignment of matrix channel %d to invalid output channel %d",
582
                                  ch, ch_assign);
583
            return AVERROR_PATCHWELCOME;
584
        }
585
4370
        s->ch_assign[ch_assign] = ch;
586
    }
587
588
1757
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
589
590
1757
    if (checksum != get_bits(gbp, 8))
591
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
592
593
    /* Set default decoding parameters. */
594
1757
    s->param_presence_flags   = 0xff;
595
1757
    s->num_primitive_matrices = 0;
596
1757
    s->blocksize              = 8;
597
1757
    s->lossless_check_data    = 0;
598
599
1757
    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
600
1757
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
601
602
5699
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
603
3942
        ChannelParams *cp = &s->channel_params[ch];
604
3942
        cp->filter_params[FIR].order = 0;
605
3942
        cp->filter_params[IIR].order = 0;
606
3942
        cp->filter_params[FIR].shift = 0;
607
3942
        cp->filter_params[IIR].shift = 0;
608
609
        /* Default audio coding is 24-bit raw PCM. */
610
3942
        cp->huff_offset      = 0;
611
3942
        cp->sign_huff_offset = -(1 << 23);
612
3942
        cp->codebook         = 0;
613
3942
        cp->huff_lsbs        = 24;
614
    }
615
616
1757
    if (substr == m->max_decoded_substream) {
617
1543
        m->avctx->channels       = s->max_matrix_channel + 1;
618
1543
        m->avctx->channel_layout = s->mask;
619
3086
        m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
620
1543
                                                               s->output_shift,
621
1543
                                                               s->max_matrix_channel,
622
1543
                                                               m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
623
624

1543
        if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
625
            if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
626
                m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
627
                int i = s->ch_assign[4];
628
                s->ch_assign[4] = s->ch_assign[3];
629
                s->ch_assign[3] = s->ch_assign[2];
630
                s->ch_assign[2] = i;
631
            } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
632
                FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
633
                FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
634
            }
635
        }
636
637
    }
638
639
1757
    return 0;
640
}
641
642
/** Read parameters for one of the prediction filters. */
643
644
4446
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
645
                              unsigned int substr, unsigned int channel,
646
                              unsigned int filter)
647
{
648
4446
    SubStream *s = &m->substream[substr];
649
4446
    FilterParams *fp = &s->channel_params[channel].filter_params[filter];
650
4446
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
651
4446
    const char fchar = filter ? 'I' : 'F';
652
    int i, order;
653
654
    // Filter is 0 for FIR, 1 for IIR.
655
4446
    av_assert0(filter < 2);
656
657
4446
    if (m->filter_changed[channel][filter]++ > 1) {
658
        av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
659
        return AVERROR_INVALIDDATA;
660
    }
661
662
4446
    order = get_bits(gbp, 4);
663
4446
    if (order > max_order) {
664
        av_log(m->avctx, AV_LOG_ERROR,
665
               "%cIR filter order %d is greater than maximum %d.\n",
666
               fchar, order, max_order);
667
        return AVERROR_INVALIDDATA;
668
    }
669
4446
    fp->order = order;
670
671
4446
    if (order > 0) {
672
4446
        int32_t *fcoeff = s->channel_params[channel].coeff[filter];
673
        int coeff_bits, coeff_shift;
674
675
4446
        fp->shift = get_bits(gbp, 4);
676
677
4446
        coeff_bits  = get_bits(gbp, 5);
678
4446
        coeff_shift = get_bits(gbp, 3);
679

4446
        if (coeff_bits < 1 || coeff_bits > 16) {
680
            av_log(m->avctx, AV_LOG_ERROR,
681
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
682
                   fchar);
683
            return AVERROR_INVALIDDATA;
684
        }
685
4446
        if (coeff_bits + coeff_shift > 16) {
686
            av_log(m->avctx, AV_LOG_ERROR,
687
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
688
                   fchar);
689
            return AVERROR_INVALIDDATA;
690
        }
691
692
23529
        for (i = 0; i < order; i++)
693
19083
            fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
694
695
4446
        if (get_bits1(gbp)) {
696
            int state_bits, state_shift;
697
698
502
            if (filter == FIR) {
699
                av_log(m->avctx, AV_LOG_ERROR,
700
                       "FIR filter has state data specified.\n");
701
                return AVERROR_INVALIDDATA;
702
            }
703
704
502
            state_bits  = get_bits(gbp, 4);
705
502
            state_shift = get_bits(gbp, 4);
706
707
            /* TODO: Check validity of state data. */
708
709
1443
            for (i = 0; i < order; i++)
710
941
                fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
711
        }
712
    }
713
714
4446
    return 0;
715
}
716
717
/** Read parameters for primitive matrices. */
718
719
1474
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
720
{
721
1474
    SubStream *s = &m->substream[substr];
722
    unsigned int mat, ch;
723
2948
    const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
724
                                     ? MAX_MATRICES_MLP
725
1474
                                     : MAX_MATRICES_TRUEHD;
726
727
1474
    if (m->matrix_changed++ > 1) {
728
        av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
729
        return AVERROR_INVALIDDATA;
730
    }
731
732
1474
    s->num_primitive_matrices = get_bits(gbp, 4);
733
734
1474
    if (s->num_primitive_matrices > max_primitive_matrices) {
735
        av_log(m->avctx, AV_LOG_ERROR,
736
               "Number of primitive matrices cannot be greater than %d.\n",
737
               max_primitive_matrices);
738
        goto error;
739
    }
740
741
3805
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
742
        int frac_bits, max_chan;
743
2331
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
744
2331
        frac_bits             = get_bits(gbp, 4);
745
2331
        s->lsb_bypass   [mat] = get_bits1(gbp);
746
747
2331
        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
748
            av_log(m->avctx, AV_LOG_ERROR,
749
                    "Invalid channel %d specified as output from matrix.\n",
750
                    s->matrix_out_ch[mat]);
751
            goto error;
752
        }
753
2331
        if (frac_bits > 14) {
754
            av_log(m->avctx, AV_LOG_ERROR,
755
                    "Too many fractional bits specified.\n");
756
            goto error;
757
        }
758
759
2331
        max_chan = s->max_matrix_channel;
760
2331
        if (!s->noise_type)
761
1688
            max_chan+=2;
762
763
12941
        for (ch = 0; ch <= max_chan; ch++) {
764
10610
            int coeff_val = 0;
765
10610
            if (get_bits1(gbp))
766
5923
                coeff_val = get_sbits(gbp, frac_bits + 2);
767
768
10610
            s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
769
        }
770
771
2331
        if (s->noise_type)
772
643
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
773
        else
774
1688
            s->matrix_noise_shift[mat] = 0;
775
    }
776
777
1474
    return 0;
778
error:
779
    s->num_primitive_matrices = 0;
780
    memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
781
782
    return AVERROR_INVALIDDATA;
783
}
784
785
/** Read channel parameters. */
786
787
11750
static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
788
                               GetBitContext *gbp, unsigned int ch)
789
{
790
11750
    SubStream *s = &m->substream[substr];
791
11750
    ChannelParams *cp = &s->channel_params[ch];
792
11750
    FilterParams *fir = &cp->filter_params[FIR];
793
11750
    FilterParams *iir = &cp->filter_params[IIR];
794
    int ret;
795
796
11750
    if (s->param_presence_flags & PARAM_FIR)
797
11750
        if (get_bits1(gbp))
798
3944
            if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
799
                return ret;
800
801
11750
    if (s->param_presence_flags & PARAM_IIR)
802
11750
        if (get_bits1(gbp))
803
502
            if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
804
                return ret;
805
806
11750
    if (fir->order + iir->order > 8) {
807
        av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
808
        return AVERROR_INVALIDDATA;
809
    }
810
811

11750
    if (fir->order && iir->order &&
812
949
        fir->shift != iir->shift) {
813
        av_log(m->avctx, AV_LOG_ERROR,
814
                "FIR and IIR filters must use the same precision.\n");
815
        return AVERROR_INVALIDDATA;
816
    }
817
    /* The FIR and IIR filters must have the same precision.
818
     * To simplify the filtering code, only the precision of the
819
     * FIR filter is considered. If only the IIR filter is employed,
820
     * the FIR filter precision is set to that of the IIR filter, so
821
     * that the filtering code can use it. */
822

11750
    if (!fir->order && iir->order)
823
        fir->shift = iir->shift;
824
825
11750
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
826
11750
        if (get_bits1(gbp))
827
2180
            cp->huff_offset = get_sbits(gbp, 15);
828
829
11750
    cp->codebook  = get_bits(gbp, 2);
830
11750
    cp->huff_lsbs = get_bits(gbp, 5);
831
832
11750
    if (cp->huff_lsbs > 24) {
833
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
834
        cp->huff_lsbs = 0;
835
        return AVERROR_INVALIDDATA;
836
    }
837
838
11750
    return 0;
839
}
840
841
/** Read decoding parameters that change more often than those in the restart
842
 *  header. */
843
844
13437
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
845
                                unsigned int substr)
846
{
847
13437
    SubStream *s = &m->substream[substr];
848
    unsigned int ch;
849
13437
    int ret = 0;
850
13437
    unsigned recompute_sho = 0;
851
852
13437
    if (s->param_presence_flags & PARAM_PRESENCE)
853
13437
        if (get_bits1(gbp))
854
            s->param_presence_flags = get_bits(gbp, 8);
855
856
13437
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
857
13437
        if (get_bits1(gbp)) {
858
3514
            s->blocksize = get_bits(gbp, 9);
859

3514
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
860
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
861
                s->blocksize = 0;
862
                return AVERROR_INVALIDDATA;
863
            }
864
        }
865
866
13437
    if (s->param_presence_flags & PARAM_MATRIX)
867
13437
        if (get_bits1(gbp))
868
1474
            if ((ret = read_matrix_params(m, substr, gbp)) < 0)
869
                return ret;
870
871
13437
    if (s->param_presence_flags & PARAM_OUTSHIFT)
872
13437
        if (get_bits1(gbp)) {
873
4344
            for (ch = 0; ch <= s->max_matrix_channel; ch++) {
874
3180
                s->output_shift[ch] = get_sbits(gbp, 4);
875
3180
                if (s->output_shift[ch] < 0) {
876
                    avpriv_request_sample(m->avctx, "Negative output_shift");
877
                    s->output_shift[ch] = 0;
878
                }
879
            }
880
1164
            if (substr == m->max_decoded_substream)
881
1152
                m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
882
1152
                                                                       s->output_shift,
883
1152
                                                                       s->max_matrix_channel,
884
1152
                                                                       m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
885
        }
886
887
13437
    if (s->param_presence_flags & PARAM_QUANTSTEP)
888
13437
        if (get_bits1(gbp))
889
6127
            for (ch = 0; ch <= s->max_channel; ch++) {
890
4370
                s->quant_step_size[ch] = get_bits(gbp, 4);
891
892
4370
                recompute_sho |= 1<<ch;
893
            }
894
895
43337
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
896
29900
        if (get_bits1(gbp)) {
897
11750
            recompute_sho |= 1<<ch;
898
11750
            if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
899
                goto fail;
900
        }
901
902
903
13437
fail:
904
46363
    for (ch = 0; ch <= s->max_channel; ch++) {
905
32926
        if (recompute_sho & (1<<ch)) {
906
12178
            ChannelParams *cp = &s->channel_params[ch];
907
908

12178
            if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
909
                if (ret >= 0) {
910
                    av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
911
                    ret = AVERROR_INVALIDDATA;
912
                }
913
                s->quant_step_size[ch] = 0;
914
            }
915
916
12178
            cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
917
        }
918
    }
919
13437
    return ret;
920
}
921
922
#define MSB_MASK(bits)  (-1u << (bits))
923
924
/** Generate PCM samples using the prediction filters and residual values
925
 *  read from the data stream, and update the filter state. */
926
927
49156
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
928
                           unsigned int channel)
929
{
930
49156
    SubStream *s = &m->substream[substr];
931
49156
    const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
932
    int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
933
49156
    int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
934
49156
    int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
935
49156
    FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
936
49156
    FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
937
49156
    unsigned int filter_shift = fir->shift;
938
49156
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
939
940
49156
    memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
941
49156
    memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
942
943
49156
    m->dsp.mlp_filter_channel(firbuf, fircoeff,
944
49156
                              fir->order, iir->order,
945
49156
                              filter_shift, mask, s->blocksize,
946
49156
                              &m->sample_buffer[s->blockpos][channel]);
947
948
49156
    memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
949
49156
    memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
950
49156
}
951
952
/** Read a block of PCM residual data (or actual if no filtering active). */
953
954
20954
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
955
                           unsigned int substr)
956
{
957
20954
    SubStream *s = &m->substream[substr];
958
20954
    unsigned int i, ch, expected_stream_pos = 0;
959
    int ret;
960
961
20954
    if (s->data_check_present) {
962
        expected_stream_pos  = get_bits_count(gbp);
963
        expected_stream_pos += get_bits(gbp, 16);
964
        avpriv_request_sample(m->avctx,
965
                              "Substreams with VLC block size check info");
966
    }
967
968
20954
    if (s->blockpos + s->blocksize > m->access_unit_size) {
969
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
970
        return AVERROR_INVALIDDATA;
971
    }
972
973
20954
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
974
20954
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
975
976
788834
    for (i = 0; i < s->blocksize; i++)
977
767880
        if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
978
            return ret;
979
980
70110
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
981
49156
        filter_channel(m, substr, ch);
982
983
20954
    s->blockpos += s->blocksize;
984
985
20954
    if (s->data_check_present) {
986
        if (get_bits_count(gbp) != expected_stream_pos)
987
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
988
        skip_bits(gbp, 8);
989
    }
990
991
20954
    return 0;
992
}
993
994
/** Data table used for TrueHD noise generation function. */
995
996
static const int8_t noise_table[256] = {
997
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
998
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
999
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
1000
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
1001
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
1002
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
1003
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
1004
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
1005
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
1006
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
1007
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
1008
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
1009
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
1010
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
1011
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
1012
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
1013
};
1014
1015
/** Noise generation functions.
1016
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
1017
 *  sequence generators, used to generate noise data which is used when the
1018
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
1019
 *  to compression, or just obfuscate the decoder. Are they for some kind of
1020
 *  dithering? */
1021
1022
/** Generate two channels of noise, used in the matrix when
1023
 *  restart sync word == 0x31ea. */
1024
1025
12377
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1026
{
1027
12377
    SubStream *s = &m->substream[substr];
1028
    unsigned int i;
1029
12377
    uint32_t seed = s->noisegen_seed;
1030
12377
    unsigned int maxchan = s->max_matrix_channel;
1031
1032
507457
    for (i = 0; i < s->blockpos; i++) {
1033
495080
        uint16_t seed_shr7 = seed >> 7;
1034
495080
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
1035
495080
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   * (1 << s->noise_shift);
1036
1037
495080
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1038
    }
1039
1040
12377
    s->noisegen_seed = seed;
1041
12377
}
1042
1043
/** Generate a block of noise, used when restart sync word == 0x31eb. */
1044
1045
3410
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1046
{
1047
3410
    SubStream *s = &m->substream[substr];
1048
    unsigned int i;
1049
3410
    uint32_t seed = s->noisegen_seed;
1050
1051
221650
    for (i = 0; i < m->access_unit_size_pow2; i++) {
1052
218240
        uint8_t seed_shr15 = seed >> 15;
1053
218240
        m->noise_buffer[i] = noise_table[seed_shr15];
1054
218240
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1055
    }
1056
1057
3410
    s->noisegen_seed = seed;
1058
3410
}
1059
1060
/** Write the audio data into the output buffer. */
1061
1062
15787
static int output_data(MLPDecodeContext *m, unsigned int substr,
1063
                       AVFrame *frame, int *got_frame_ptr)
1064
{
1065
15787
    AVCodecContext *avctx = m->avctx;
1066
15787
    SubStream *s = &m->substream[substr];
1067
    unsigned int mat;
1068
    unsigned int maxchan;
1069
    int ret;
1070
15787
    int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1071
1072
15787
    if (m->avctx->channels != s->max_matrix_channel + 1) {
1073
        av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1074
        return AVERROR_INVALIDDATA;
1075
    }
1076
1077
15787
    if (!s->blockpos) {
1078
        av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1079
        return AVERROR_INVALIDDATA;
1080
    }
1081
1082
15787
    maxchan = s->max_matrix_channel;
1083
15787
    if (!s->noise_type) {
1084
12377
        generate_2_noise_channels(m, substr);
1085
12377
        maxchan += 2;
1086
    } else {
1087
3410
        fill_noise_buffer(m, substr);
1088
    }
1089
1090
    /* Apply the channel matrices in turn to reconstruct the original audio
1091
     * samples. */
1092
39544
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1093
23757
        unsigned int dest_ch = s->matrix_out_ch[mat];
1094
23757
        m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1095
23757
                                    s->matrix_coeff[mat],
1096
23757
                                    &m->bypassed_lsbs[0][mat],
1097
23757
                                    m->noise_buffer,
1098
23757
                                    s->num_primitive_matrices - mat,
1099
                                    dest_ch,
1100
23757
                                    s->blockpos,
1101
                                    maxchan,
1102
23757
                                    s->matrix_noise_shift[mat],
1103
                                    m->access_unit_size_pow2,
1104
23757
                                    MSB_MASK(s->quant_step_size[dest_ch]));
1105
    }
1106
1107
    /* get output buffer */
1108
15787
    frame->nb_samples = s->blockpos;
1109
15787
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1110
        return ret;
1111
31574
    s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1112
15787
                                                    s->blockpos,
1113
15787
                                                    m->sample_buffer,
1114
15787
                                                    frame->data[0],
1115
15787
                                                    s->ch_assign,
1116
15787
                                                    s->output_shift,
1117
15787
                                                    s->max_matrix_channel,
1118
                                                    is32);
1119
1120
    /* Update matrix encoding side data */
1121
15787
    if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1122
        return ret;
1123
1124
15787
    *got_frame_ptr = 1;
1125
1126
15787
    return 0;
1127
}
1128
1129
/** Read an access unit from the stream.
1130
 *  @return negative on error, 0 if not enough data is present in the input stream,
1131
 *  otherwise the number of bytes consumed. */
1132
1133
15787
static int read_access_unit(AVCodecContext *avctx, void* data,
1134
                            int *got_frame_ptr, AVPacket *avpkt)
1135
{
1136
15787
    const uint8_t *buf = avpkt->data;
1137
15787
    int buf_size = avpkt->size;
1138
15787
    MLPDecodeContext *m = avctx->priv_data;
1139
    GetBitContext gb;
1140
    unsigned int length, substr;
1141
    unsigned int substream_start;
1142
15787
    unsigned int header_size = 4;
1143
15787
    unsigned int substr_header_size = 0;
1144
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
1145
    uint16_t substream_data_len[MAX_SUBSTREAMS];
1146
    uint8_t parity_bits;
1147
    int ret;
1148
1149
15787
    if (buf_size < 4)
1150
        return AVERROR_INVALIDDATA;
1151
1152
15787
    length = (AV_RB16(buf) & 0xfff) * 2;
1153
1154

15787
    if (length < 4 || length > buf_size)
1155
        return AVERROR_INVALIDDATA;
1156
1157
15787
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1158
1159
15787
    m->is_major_sync_unit = 0;
1160
15787
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1161
1543
        if (read_major_sync(m, &gb) < 0)
1162
            goto error;
1163
1543
        m->is_major_sync_unit = 1;
1164
1543
        header_size += m->major_sync_header_size;
1165
    }
1166
1167
15787
    if (!m->params_valid) {
1168
        av_log(m->avctx, AV_LOG_WARNING,
1169
               "Stream parameters not seen; skipping frame.\n");
1170
        *got_frame_ptr = 0;
1171
        return length;
1172
    }
1173
1174
15787
    substream_start = 0;
1175
1176
38394
    for (substr = 0; substr < m->num_substreams; substr++) {
1177
        int extraword_present, checkdata_present, end, nonrestart_substr;
1178
1179
22607
        extraword_present = get_bits1(&gb);
1180
22607
        nonrestart_substr = get_bits1(&gb);
1181
22607
        checkdata_present = get_bits1(&gb);
1182
22607
        skip_bits1(&gb);
1183
1184
22607
        end = get_bits(&gb, 12) * 2;
1185
1186
22607
        substr_header_size += 2;
1187
1188
22607
        if (extraword_present) {
1189
104
            if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1190
                av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1191
                goto error;
1192
            }
1193
104
            skip_bits(&gb, 16);
1194
104
            substr_header_size += 2;
1195
        }
1196
1197
22607
        if (length < header_size + substr_header_size) {
1198
            av_log(m->avctx, AV_LOG_ERROR, "Insufficient data for headers\n");
1199
            goto error;
1200
        }
1201
1202
22607
        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1203
            av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1204
            goto error;
1205
        }
1206
1207
22607
        if (end + header_size + substr_header_size > length) {
1208
            av_log(m->avctx, AV_LOG_ERROR,
1209
                   "Indicated length of substream %d data goes off end of "
1210
                   "packet.\n", substr);
1211
            end = length - header_size - substr_header_size;
1212
        }
1213
1214
22607
        if (end < substream_start) {
1215
            av_log(avctx, AV_LOG_ERROR,
1216
                   "Indicated end offset of substream %d data "
1217
                   "is smaller than calculated start offset.\n",
1218
                   substr);
1219
            goto error;
1220
        }
1221
1222
22607
        if (substr > m->max_decoded_substream)
1223
3196
            continue;
1224
1225
19411
        substream_parity_present[substr] = checkdata_present;
1226
19411
        substream_data_len[substr] = end - substream_start;
1227
19411
        substream_start = end;
1228
    }
1229
1230
15787
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
1231
15787
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1232
1233
15787
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1234
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1235
        goto error;
1236
    }
1237
1238
15787
    buf += header_size + substr_header_size;
1239
1240
34984
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1241
19197
        SubStream *s = &m->substream[substr];
1242
19197
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1243
1244
19197
        m->matrix_changed = 0;
1245
19197
        memset(m->filter_changed, 0, sizeof(m->filter_changed));
1246
1247
19197
        s->blockpos = 0;
1248
        do {
1249
20954
            if (get_bits1(&gb)) {
1250
13437
                if (get_bits1(&gb)) {
1251
                    /* A restart header should be present. */
1252
1757
                    if (read_restart_header(m, &gb, buf, substr) < 0)
1253
                        goto next_substr;
1254
1757
                    s->restart_seen = 1;
1255
                }
1256
1257
13437
                if (!s->restart_seen)
1258
                    goto next_substr;
1259
13437
                if (read_decoding_params(m, &gb, substr) < 0)
1260
                    goto next_substr;
1261
            }
1262
1263
20954
            if (!s->restart_seen)
1264
                goto next_substr;
1265
1266
20954
            if ((ret = read_block_data(m, &gb, substr)) < 0)
1267
                return ret;
1268
1269
20954
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1270
                goto substream_length_mismatch;
1271
1272
20954
        } while (!get_bits1(&gb));
1273
1274
19197
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1275
1276
19197
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1277
            int shorten_by;
1278
1279
            if (get_bits(&gb, 16) != 0xD234)
1280
                return AVERROR_INVALIDDATA;
1281
1282
            shorten_by = get_bits(&gb, 16);
1283
            if      (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1284
                s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1285
            else if (m->avctx->codec_id == AV_CODEC_ID_MLP    && shorten_by != 0xD234)
1286
                return AVERROR_INVALIDDATA;
1287
1288
            if (substr == m->max_decoded_substream)
1289
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1290
        }
1291
1292
19197
        if (substream_parity_present[substr]) {
1293
            uint8_t parity, checksum;
1294
1295
19197
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1296
                goto substream_length_mismatch;
1297
1298
19197
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1299
19197
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1300
1301
19197
            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1302
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1303
19197
            if ( get_bits(&gb, 8)           != checksum)
1304
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1305
        }
1306
1307
19197
        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1308
            goto substream_length_mismatch;
1309
1310
19197
next_substr:
1311
19197
        if (!s->restart_seen)
1312
            av_log(m->avctx, AV_LOG_ERROR,
1313
                   "No restart header present in substream %d.\n", substr);
1314
1315
19197
        buf += substream_data_len[substr];
1316
    }
1317
1318
15787
    if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1319
        return ret;
1320
1321
15787
    return length;
1322
1323
substream_length_mismatch:
1324
    av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1325
    return AVERROR_INVALIDDATA;
1326
1327
error:
1328
    m->params_valid = 0;
1329
    return AVERROR_INVALIDDATA;
1330
}
1331
1332
#if CONFIG_MLP_DECODER
1333
AVCodec ff_mlp_decoder = {
1334
    .name           = "mlp",
1335
    .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1336
    .type           = AVMEDIA_TYPE_AUDIO,
1337
    .id             = AV_CODEC_ID_MLP,
1338
    .priv_data_size = sizeof(MLPDecodeContext),
1339
    .init           = mlp_decode_init,
1340
    .decode         = read_access_unit,
1341
    .capabilities   = AV_CODEC_CAP_DR1,
1342
};
1343
#endif
1344
#if CONFIG_TRUEHD_DECODER
1345
AVCodec ff_truehd_decoder = {
1346
    .name           = "truehd",
1347
    .long_name      = NULL_IF_CONFIG_SMALL("TrueHD"),
1348
    .type           = AVMEDIA_TYPE_AUDIO,
1349
    .id             = AV_CODEC_ID_TRUEHD,
1350
    .priv_data_size = sizeof(MLPDecodeContext),
1351
    .init           = mlp_decode_init,
1352
    .decode         = read_access_unit,
1353
    .capabilities   = AV_CODEC_CAP_DR1,
1354
};
1355
#endif /* CONFIG_TRUEHD_DECODER */