GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mlpdec.c Lines: 455 623 73.0 %
Date: 2021-04-20 15:25:36 Branches: 265 405 65.4 %

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 "libavutil/mem_internal.h"
34
#include "libavutil/thread.h"
35
#include "get_bits.h"
36
#include "internal.h"
37
#include "libavutil/crc.h"
38
#include "parser.h"
39
#include "mlp_parse.h"
40
#include "mlpdsp.h"
41
#include "mlp.h"
42
#include "config.h"
43
44
/** number of bits used for VLC lookup - longest Huffman code is 9 */
45
#if ARCH_ARM
46
#define VLC_BITS            5
47
#define VLC_STATIC_SIZE     64
48
#else
49
#define VLC_BITS            9
50
#define VLC_STATIC_SIZE     512
51
#endif
52
53
typedef struct SubStream {
54
    /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
55
    uint8_t     restart_seen;
56
57
    //@{
58
    /** restart header data */
59
    /// The type of noise to be used in the rematrix stage.
60
    uint16_t    noise_type;
61
62
    /// The index of the first channel coded in this substream.
63
    uint8_t     min_channel;
64
    /// The index of the last channel coded in this substream.
65
    uint8_t     max_channel;
66
    /// The number of channels input into the rematrix stage.
67
    uint8_t     max_matrix_channel;
68
    /// For each channel output by the matrix, the output channel to map it to
69
    uint8_t     ch_assign[MAX_CHANNELS];
70
    /// The channel layout for this substream
71
    uint64_t    mask;
72
    /// The matrix encoding mode for this substream
73
    enum AVMatrixEncoding matrix_encoding;
74
75
    /// Channel coding parameters for channels in the substream
76
    ChannelParams channel_params[MAX_CHANNELS];
77
78
    /// The left shift applied to random noise in 0x31ea substreams.
79
    uint8_t     noise_shift;
80
    /// The current seed value for the pseudorandom noise generator(s).
81
    uint32_t    noisegen_seed;
82
83
    /// Set if the substream contains extra info to check the size of VLC blocks.
84
    uint8_t     data_check_present;
85
86
    /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
87
    uint8_t     param_presence_flags;
88
#define PARAM_BLOCKSIZE     (1 << 7)
89
#define PARAM_MATRIX        (1 << 6)
90
#define PARAM_OUTSHIFT      (1 << 5)
91
#define PARAM_QUANTSTEP     (1 << 4)
92
#define PARAM_FIR           (1 << 3)
93
#define PARAM_IIR           (1 << 2)
94
#define PARAM_HUFFOFFSET    (1 << 1)
95
#define PARAM_PRESENCE      (1 << 0)
96
    //@}
97
98
    //@{
99
    /** matrix data */
100
101
    /// Number of matrices to be applied.
102
    uint8_t     num_primitive_matrices;
103
104
    /// matrix output channel
105
    uint8_t     matrix_out_ch[MAX_MATRICES];
106
107
    /// Whether the LSBs of the matrix output are encoded in the bitstream.
108
    uint8_t     lsb_bypass[MAX_MATRICES];
109
    /// Matrix coefficients, stored as 2.14 fixed point.
110
    DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS];
111
    /// Left shift to apply to noise values in 0x31eb substreams.
112
    uint8_t     matrix_noise_shift[MAX_MATRICES];
113
    //@}
114
115
    /// Left shift to apply to Huffman-decoded residuals.
116
    uint8_t     quant_step_size[MAX_CHANNELS];
117
118
    /// number of PCM samples in current audio block
119
    uint16_t    blocksize;
120
    /// Number of PCM samples decoded so far in this frame.
121
    uint16_t    blockpos;
122
123
    /// Left shift to apply to decoded PCM values to get final 24-bit output.
124
    int8_t      output_shift[MAX_CHANNELS];
125
126
    /// Running XOR of all output samples.
127
    int32_t     lossless_check_data;
128
129
} SubStream;
130
131
typedef struct MLPDecodeContext {
132
    AVCodecContext *avctx;
133
134
    /// Current access unit being read has a major sync.
135
    int         is_major_sync_unit;
136
137
    /// Size of the major sync unit, in bytes
138
    int         major_sync_header_size;
139
140
    /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
141
    uint8_t     params_valid;
142
143
    /// Number of substreams contained within this stream.
144
    uint8_t     num_substreams;
145
146
    /// Index of the last substream to decode - further substreams are skipped.
147
    uint8_t     max_decoded_substream;
148
149
    /// Stream needs channel reordering to comply with FFmpeg's channel order
150
    uint8_t     needs_reordering;
151
152
    /// number of PCM samples contained in each frame
153
    int         access_unit_size;
154
    /// next power of two above the number of samples in each frame
155
    int         access_unit_size_pow2;
156
157
    SubStream   substream[MAX_SUBSTREAMS];
158
159
    int         matrix_changed;
160
    int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
161
162
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
163
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
164
    DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];
165
166
    MLPDSPContext dsp;
167
} MLPDecodeContext;
168
169
static const uint64_t thd_channel_order[] = {
170
    AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT,                     // LR
171
    AV_CH_FRONT_CENTER,                                      // C
172
    AV_CH_LOW_FREQUENCY,                                     // LFE
173
    AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT,                       // LRs
174
    AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT,             // LRvh
175
    AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
176
    AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT,                       // LRrs
177
    AV_CH_BACK_CENTER,                                       // Cs
178
    AV_CH_TOP_CENTER,                                        // Ts
179
    AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
180
    AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT,                       // LRw
181
    AV_CH_TOP_FRONT_CENTER,                                  // Cvh
182
    AV_CH_LOW_FREQUENCY_2,                                   // LFE2
183
};
184
185
1764
static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
186
{
187

1764
    return channel_layout && ((channel_layout & mask) == channel_layout);
188
}
189
190
2166
static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
191
                                                   int index)
192
{
193
    int i;
194
195
2166
    if (av_get_channel_layout_nb_channels(channel_layout) <= index)
196
        return 0;
197
198
5873
    for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
199

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

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

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

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

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

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

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

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

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

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

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

11786
    if (!fir->order && iir->order)
824
        fir->shift = iir->shift;
825
826
11786
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
827
11786
        if (get_bits1(gbp))
828
2191
            cp->huff_offset = get_sbits(gbp, 15);
829
830
11786
    cp->codebook  = get_bits(gbp, 2);
831
11786
    cp->huff_lsbs = get_bits(gbp, 5);
832
833

11786
    if (cp->codebook > 0 && cp->huff_lsbs > 24) {
834
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
835
        cp->huff_lsbs = 0;
836
        return AVERROR_INVALIDDATA;
837
    }
838
839
11786
    return 0;
840
}
841
842
/** Read decoding parameters that change more often than those in the restart
843
 *  header. */
844
845
13451
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
846
                                unsigned int substr)
847
{
848
13451
    SubStream *s = &m->substream[substr];
849
    unsigned int ch;
850
13451
    int ret = 0;
851
13451
    unsigned recompute_sho = 0;
852
853
13451
    if (s->param_presence_flags & PARAM_PRESENCE)
854
13451
        if (get_bits1(gbp))
855
            s->param_presence_flags = get_bits(gbp, 8);
856
857
13451
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
858
13451
        if (get_bits1(gbp)) {
859
3521
            s->blocksize = get_bits(gbp, 9);
860

3521
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
861
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
862
                s->blocksize = 0;
863
                return AVERROR_INVALIDDATA;
864
            }
865
        }
866
867
13451
    if (s->param_presence_flags & PARAM_MATRIX)
868
13451
        if (get_bits1(gbp))
869
1480
            if ((ret = read_matrix_params(m, substr, gbp)) < 0)
870
                return ret;
871
872
13451
    if (s->param_presence_flags & PARAM_OUTSHIFT)
873
13451
        if (get_bits1(gbp)) {
874
4370
            for (ch = 0; ch <= s->max_matrix_channel; ch++) {
875
3202
                s->output_shift[ch] = get_sbits(gbp, 4);
876
3202
                if (s->output_shift[ch] < 0) {
877
                    avpriv_request_sample(m->avctx, "Negative output_shift");
878
                    s->output_shift[ch] = 0;
879
                }
880
            }
881
1168
            if (substr == m->max_decoded_substream)
882
1154
                m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
883
1154
                                                                       s->output_shift,
884
1154
                                                                       s->max_matrix_channel,
885
1154
                                                                       m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
886
        }
887
888
13451
    if (s->param_presence_flags & PARAM_QUANTSTEP)
889
13451
        if (get_bits1(gbp))
890
6143
            for (ch = 0; ch <= s->max_channel; ch++) {
891
4382
                s->quant_step_size[ch] = get_bits(gbp, 4);
892
893
4382
                recompute_sho |= 1<<ch;
894
            }
895
896
43387
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
897
29936
        if (get_bits1(gbp)) {
898
11786
            recompute_sho |= 1<<ch;
899
11786
            if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
900
                goto fail;
901
        }
902
903
904
13451
fail:
905
46433
    for (ch = 0; ch <= s->max_channel; ch++) {
906
32982
        if (recompute_sho & (1<<ch)) {
907
12216
            ChannelParams *cp = &s->channel_params[ch];
908
909

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

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