Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ d3f126df

History | View | Annotate | Download (39.9 KB)

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 "dsputil.h"
31
#include "libavutil/intreadwrite.h"
32
#include "get_bits.h"
33
#include "libavutil/crc.h"
34
#include "parser.h"
35
#include "mlp_parser.h"
36
#include "mlp.h"
37

    
38
/** number of bits used for VLC lookup - longest Huffman code is 9 */
39
#define VLC_BITS            9
40

    
41

    
42
static const char* sample_message =
43
    "Please file a bug report following the instructions at "
44
    "http://ffmpeg.org/bugreports.html and include "
45
    "a sample of this file.";
46

    
47
typedef struct SubStream {
48
    //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
49
    uint8_t     restart_seen;
50

    
51
    //@{
52
    /** restart header data */
53
    //! The type of noise to be used in the rematrix stage.
54
    uint16_t    noise_type;
55

    
56
    //! The index of the first channel coded in this substream.
57
    uint8_t     min_channel;
58
    //! The index of the last channel coded in this substream.
59
    uint8_t     max_channel;
60
    //! The number of channels input into the rematrix stage.
61
    uint8_t     max_matrix_channel;
62
    //! For each channel output by the matrix, the output channel to map it to
63
    uint8_t     ch_assign[MAX_CHANNELS];
64

    
65
    //! Channel coding parameters for channels in the substream
66
    ChannelParams channel_params[MAX_CHANNELS];
67

    
68
    //! The left shift applied to random noise in 0x31ea substreams.
69
    uint8_t     noise_shift;
70
    //! The current seed value for the pseudorandom noise generator(s).
71
    uint32_t    noisegen_seed;
72

    
73
    //! Set if the substream contains extra info to check the size of VLC blocks.
74
    uint8_t     data_check_present;
75

    
76
    //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
77
    uint8_t     param_presence_flags;
78
#define PARAM_BLOCKSIZE     (1 << 7)
79
#define PARAM_MATRIX        (1 << 6)
80
#define PARAM_OUTSHIFT      (1 << 5)
81
#define PARAM_QUANTSTEP     (1 << 4)
82
#define PARAM_FIR           (1 << 3)
83
#define PARAM_IIR           (1 << 2)
84
#define PARAM_HUFFOFFSET    (1 << 1)
85
#define PARAM_PRESENCE      (1 << 0)
86
    //@}
87

    
88
    //@{
89
    /** matrix data */
90

    
91
    //! Number of matrices to be applied.
92
    uint8_t     num_primitive_matrices;
93

    
94
    //! matrix output channel
95
    uint8_t     matrix_out_ch[MAX_MATRICES];
96

    
97
    //! Whether the LSBs of the matrix output are encoded in the bitstream.
98
    uint8_t     lsb_bypass[MAX_MATRICES];
99
    //! Matrix coefficients, stored as 2.14 fixed point.
100
    int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
101
    //! Left shift to apply to noise values in 0x31eb substreams.
102
    uint8_t     matrix_noise_shift[MAX_MATRICES];
103
    //@}
104

    
105
    //! Left shift to apply to Huffman-decoded residuals.
106
    uint8_t     quant_step_size[MAX_CHANNELS];
107

    
108
    //! number of PCM samples in current audio block
109
    uint16_t    blocksize;
110
    //! Number of PCM samples decoded so far in this frame.
111
    uint16_t    blockpos;
112

    
113
    //! Left shift to apply to decoded PCM values to get final 24-bit output.
114
    int8_t      output_shift[MAX_CHANNELS];
115

    
116
    //! Running XOR of all output samples.
117
    int32_t     lossless_check_data;
118

    
119
} SubStream;
120

    
121
typedef struct MLPDecodeContext {
122
    AVCodecContext *avctx;
123

    
124
    //! Current access unit being read has a major sync.
125
    int         is_major_sync_unit;
126

    
127
    //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
128
    uint8_t     params_valid;
129

    
130
    //! Number of substreams contained within this stream.
131
    uint8_t     num_substreams;
132

    
133
    //! Index of the last substream to decode - further substreams are skipped.
134
    uint8_t     max_decoded_substream;
135

    
136
    //! Stream needs channel reordering to comply with FFmpeg's channel order
137
    uint8_t     needs_reordering;
138

    
139
    //! number of PCM samples contained in each frame
140
    int         access_unit_size;
141
    //! next power of two above the number of samples in each frame
142
    int         access_unit_size_pow2;
143

    
144
    SubStream   substream[MAX_SUBSTREAMS];
145

    
146
    int         matrix_changed;
147
    int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
148

    
149
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
150
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
151
    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
152

    
153
    DSPContext  dsp;
154
} MLPDecodeContext;
155

    
156
static VLC huff_vlc[3];
157

    
158
/** Initialize static data, constant between all invocations of the codec. */
159

    
160
static av_cold void init_static(void)
161
{
162
    if (!huff_vlc[0].bits) {
163
        INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
164
                    &ff_mlp_huffman_tables[0][0][1], 2, 1,
165
                    &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
166
        INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
167
                    &ff_mlp_huffman_tables[1][0][1], 2, 1,
168
                    &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
169
        INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
170
                    &ff_mlp_huffman_tables[2][0][1], 2, 1,
171
                    &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
172
    }
173

    
174
    ff_mlp_init_crc();
175
}
176

    
177
static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
178
                                          unsigned int substr, unsigned int ch)
179
{
180
    SubStream *s = &m->substream[substr];
181
    ChannelParams *cp = &s->channel_params[ch];
182
    int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
183
    int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
184
    int32_t sign_huff_offset = cp->huff_offset;
185

    
186
    if (cp->codebook > 0)
187
        sign_huff_offset -= 7 << lsb_bits;
188

    
189
    if (sign_shift >= 0)
190
        sign_huff_offset -= 1 << sign_shift;
191

    
192
    return sign_huff_offset;
193
}
194

    
195
/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
196
 *  and plain LSBs. */
197

    
198
static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
199
                                     unsigned int substr, unsigned int pos)
200
{
201
    SubStream *s = &m->substream[substr];
202
    unsigned int mat, channel;
203

    
204
    for (mat = 0; mat < s->num_primitive_matrices; mat++)
205
        if (s->lsb_bypass[mat])
206
            m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
207

    
208
    for (channel = s->min_channel; channel <= s->max_channel; channel++) {
209
        ChannelParams *cp = &s->channel_params[channel];
210
        int codebook = cp->codebook;
211
        int quant_step_size = s->quant_step_size[channel];
212
        int lsb_bits = cp->huff_lsbs - quant_step_size;
213
        int result = 0;
214

    
215
        if (codebook > 0)
216
            result = get_vlc2(gbp, huff_vlc[codebook-1].table,
217
                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
218

    
219
        if (result < 0)
220
            return -1;
221

    
222
        if (lsb_bits > 0)
223
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
224

    
225
        result  += cp->sign_huff_offset;
226
        result <<= quant_step_size;
227

    
228
        m->sample_buffer[pos + s->blockpos][channel] = result;
229
    }
230

    
231
    return 0;
232
}
233

    
234
static av_cold int mlp_decode_init(AVCodecContext *avctx)
235
{
236
    MLPDecodeContext *m = avctx->priv_data;
237
    int substr;
238

    
239
    init_static();
240
    m->avctx = avctx;
241
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
242
        m->substream[substr].lossless_check_data = 0xffffffff;
243
    dsputil_init(&m->dsp, avctx);
244

    
245
    return 0;
246
}
247

    
248
/** Read a major sync info header - contains high level information about
249
 *  the stream - sample rate, channel arrangement etc. Most of this
250
 *  information is not actually necessary for decoding, only for playback.
251
 */
252

    
253
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
254
{
255
    MLPHeaderInfo mh;
256
    int substr;
257

    
258
    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
259
        return -1;
260

    
261
    if (mh.group1_bits == 0) {
262
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
263
        return -1;
264
    }
265
    if (mh.group2_bits > mh.group1_bits) {
266
        av_log(m->avctx, AV_LOG_ERROR,
267
               "Channel group 2 cannot have more bits per sample than group 1.\n");
268
        return -1;
269
    }
270

    
271
    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
272
        av_log(m->avctx, AV_LOG_ERROR,
273
               "Channel groups with differing sample rates are not currently supported.\n");
274
        return -1;
275
    }
276

    
277
    if (mh.group1_samplerate == 0) {
278
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
279
        return -1;
280
    }
281
    if (mh.group1_samplerate > MAX_SAMPLERATE) {
282
        av_log(m->avctx, AV_LOG_ERROR,
283
               "Sampling rate %d is greater than the supported maximum (%d).\n",
284
               mh.group1_samplerate, MAX_SAMPLERATE);
285
        return -1;
286
    }
287
    if (mh.access_unit_size > MAX_BLOCKSIZE) {
288
        av_log(m->avctx, AV_LOG_ERROR,
289
               "Block size %d is greater than the supported maximum (%d).\n",
290
               mh.access_unit_size, MAX_BLOCKSIZE);
291
        return -1;
292
    }
293
    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
294
        av_log(m->avctx, AV_LOG_ERROR,
295
               "Block size pow2 %d is greater than the supported maximum (%d).\n",
296
               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
297
        return -1;
298
    }
299

    
300
    if (mh.num_substreams == 0)
301
        return -1;
302
    if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
303
        av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
304
        return -1;
305
    }
306
    if (mh.num_substreams > MAX_SUBSTREAMS) {
307
        av_log(m->avctx, AV_LOG_ERROR,
308
               "Number of substreams %d is larger than the maximum supported "
309
               "by the decoder. %s\n", mh.num_substreams, sample_message);
310
        return -1;
311
    }
312

    
313
    m->access_unit_size      = mh.access_unit_size;
314
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;
315

    
316
    m->num_substreams        = mh.num_substreams;
317
    m->max_decoded_substream = m->num_substreams - 1;
318

    
319
    m->avctx->sample_rate    = mh.group1_samplerate;
320
    m->avctx->frame_size     = mh.access_unit_size;
321

    
322
    m->avctx->bits_per_raw_sample = mh.group1_bits;
323
    if (mh.group1_bits > 16)
324
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
325
    else
326
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
327

    
328
    m->params_valid = 1;
329
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
330
        m->substream[substr].restart_seen = 0;
331

    
332
    if (mh.stream_type == 0xbb) {
333
        /* MLP stream */
334
        m->avctx->channel_layout = ff_mlp_layout[mh.channels_mlp];
335
    } else { /* mh.stream_type == 0xba */
336
        /* TrueHD stream */
337
        if (mh.channels_thd_stream2) {
338
            m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream2);
339
        } else {
340
            m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream1);
341
        }
342
        if (m->avctx->channels &&
343
            av_get_channel_layout_nb_channels(m->avctx->channel_layout) != m->avctx->channels) {
344
            m->avctx->channel_layout = 0;
345
            av_log_ask_for_sample(m->avctx, "Unknown channel layout.");
346
        }
347
    }
348

    
349
    m->needs_reordering = mh.channels_mlp >= 18 && mh.channels_mlp <= 20;
350

    
351
    return 0;
352
}
353

    
354
/** Read a restart header from a block in a substream. This contains parameters
355
 *  required to decode the audio that do not change very often. Generally
356
 *  (always) present only in blocks following a major sync. */
357

    
358
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
359
                               const uint8_t *buf, unsigned int substr)
360
{
361
    SubStream *s = &m->substream[substr];
362
    unsigned int ch;
363
    int sync_word, tmp;
364
    uint8_t checksum;
365
    uint8_t lossless_check;
366
    int start_count = get_bits_count(gbp);
367
    const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
368
                                 ? MAX_MATRIX_CHANNEL_MLP
369
                                 : MAX_MATRIX_CHANNEL_TRUEHD;
370

    
371
    sync_word = get_bits(gbp, 13);
372

    
373
    if (sync_word != 0x31ea >> 1) {
374
        av_log(m->avctx, AV_LOG_ERROR,
375
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
376
        return -1;
377
    }
378

    
379
    s->noise_type = get_bits1(gbp);
380

    
381
    if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
382
        av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
383
        return -1;
384
    }
385

    
386
    skip_bits(gbp, 16); /* Output timestamp */
387

    
388
    s->min_channel        = get_bits(gbp, 4);
389
    s->max_channel        = get_bits(gbp, 4);
390
    s->max_matrix_channel = get_bits(gbp, 4);
391

    
392
    if (s->max_matrix_channel > max_matrix_channel) {
393
        av_log(m->avctx, AV_LOG_ERROR,
394
               "Max matrix channel cannot be greater than %d.\n",
395
               max_matrix_channel);
396
        return -1;
397
    }
398

    
399
    if (s->max_channel != s->max_matrix_channel) {
400
        av_log(m->avctx, AV_LOG_ERROR,
401
               "Max channel must be equal max matrix channel.\n");
402
        return -1;
403
    }
404

    
405
    /* This should happen for TrueHD streams with >6 channels and MLP's noise
406
     * type. It is not yet known if this is allowed. */
407
    if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
408
        av_log(m->avctx, AV_LOG_ERROR,
409
               "Number of channels %d is larger than the maximum supported "
410
               "by the decoder. %s\n", s->max_channel+2, sample_message);
411
        return -1;
412
    }
413

    
414
    if (s->min_channel > s->max_channel) {
415
        av_log(m->avctx, AV_LOG_ERROR,
416
               "Substream min channel cannot be greater than max channel.\n");
417
        return -1;
418
    }
419

    
420
    if (m->avctx->request_channels > 0
421
        && s->max_channel + 1 >= m->avctx->request_channels
422
        && substr < m->max_decoded_substream) {
423
        av_log(m->avctx, AV_LOG_DEBUG,
424
               "Extracting %d channel downmix from substream %d. "
425
               "Further substreams will be skipped.\n",
426
               s->max_channel + 1, substr);
427
        m->max_decoded_substream = substr;
428
    }
429

    
430
    s->noise_shift   = get_bits(gbp,  4);
431
    s->noisegen_seed = get_bits(gbp, 23);
432

    
433
    skip_bits(gbp, 19);
434

    
435
    s->data_check_present = get_bits1(gbp);
436
    lossless_check = get_bits(gbp, 8);
437
    if (substr == m->max_decoded_substream
438
        && s->lossless_check_data != 0xffffffff) {
439
        tmp = xor_32_to_8(s->lossless_check_data);
440
        if (tmp != lossless_check)
441
            av_log(m->avctx, AV_LOG_WARNING,
442
                   "Lossless check failed - expected %02x, calculated %02x.\n",
443
                   lossless_check, tmp);
444
    }
445

    
446
    skip_bits(gbp, 16);
447

    
448
    memset(s->ch_assign, 0, sizeof(s->ch_assign));
449

    
450
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
451
        int ch_assign = get_bits(gbp, 6);
452
        if (ch_assign > s->max_matrix_channel) {
453
            av_log(m->avctx, AV_LOG_ERROR,
454
                   "Assignment of matrix channel %d to invalid output channel %d. %s\n",
455
                   ch, ch_assign, sample_message);
456
            return -1;
457
        }
458
        s->ch_assign[ch_assign] = ch;
459
    }
460

    
461
    if (m->avctx->codec_id == CODEC_ID_MLP && m->needs_reordering) {
462
        if (m->avctx->channel_layout == (AV_CH_LAYOUT_2_2|AV_CH_LOW_FREQUENCY) ||
463
            m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0) {
464
            int i = s->ch_assign[4];
465
            s->ch_assign[4] = s->ch_assign[3];
466
            s->ch_assign[3] = s->ch_assign[2];
467
            s->ch_assign[2] = i;
468
        } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1) {
469
            FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
470
            FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
471
        }
472
    }
473
    if (m->avctx->codec_id == CODEC_ID_TRUEHD &&
474
        m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
475
        FFSWAP(int, s->ch_assign[4], s->ch_assign[6]);
476
        FFSWAP(int, s->ch_assign[5], s->ch_assign[7]);
477
    }
478

    
479
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
480

    
481
    if (checksum != get_bits(gbp, 8))
482
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
483

    
484
    /* Set default decoding parameters. */
485
    s->param_presence_flags   = 0xff;
486
    s->num_primitive_matrices = 0;
487
    s->blocksize              = 8;
488
    s->lossless_check_data    = 0;
489

    
490
    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
491
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
492

    
493
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
494
        ChannelParams *cp = &s->channel_params[ch];
495
        cp->filter_params[FIR].order = 0;
496
        cp->filter_params[IIR].order = 0;
497
        cp->filter_params[FIR].shift = 0;
498
        cp->filter_params[IIR].shift = 0;
499

    
500
        /* Default audio coding is 24-bit raw PCM. */
501
        cp->huff_offset      = 0;
502
        cp->sign_huff_offset = (-1) << 23;
503
        cp->codebook         = 0;
504
        cp->huff_lsbs        = 24;
505
    }
506

    
507
    if (substr == m->max_decoded_substream)
508
        m->avctx->channels = s->max_matrix_channel + 1;
509

    
510
    return 0;
511
}
512

    
513
/** Read parameters for one of the prediction filters. */
514

    
515
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
516
                              unsigned int substr, unsigned int channel,
517
                              unsigned int filter)
518
{
519
    SubStream *s = &m->substream[substr];
520
    FilterParams *fp = &s->channel_params[channel].filter_params[filter];
521
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
522
    const char fchar = filter ? 'I' : 'F';
523
    int i, order;
524

    
525
    // Filter is 0 for FIR, 1 for IIR.
526
    assert(filter < 2);
527

    
528
    if (m->filter_changed[channel][filter]++ > 1) {
529
        av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
530
        return -1;
531
    }
532

    
533
    order = get_bits(gbp, 4);
534
    if (order > max_order) {
535
        av_log(m->avctx, AV_LOG_ERROR,
536
               "%cIR filter order %d is greater than maximum %d.\n",
537
               fchar, order, max_order);
538
        return -1;
539
    }
540
    fp->order = order;
541

    
542
    if (order > 0) {
543
        int32_t *fcoeff = s->channel_params[channel].coeff[filter];
544
        int coeff_bits, coeff_shift;
545

    
546
        fp->shift = get_bits(gbp, 4);
547

    
548
        coeff_bits  = get_bits(gbp, 5);
549
        coeff_shift = get_bits(gbp, 3);
550
        if (coeff_bits < 1 || coeff_bits > 16) {
551
            av_log(m->avctx, AV_LOG_ERROR,
552
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
553
                   fchar);
554
            return -1;
555
        }
556
        if (coeff_bits + coeff_shift > 16) {
557
            av_log(m->avctx, AV_LOG_ERROR,
558
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
559
                   fchar);
560
            return -1;
561
        }
562

    
563
        for (i = 0; i < order; i++)
564
            fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
565

    
566
        if (get_bits1(gbp)) {
567
            int state_bits, state_shift;
568

    
569
            if (filter == FIR) {
570
                av_log(m->avctx, AV_LOG_ERROR,
571
                       "FIR filter has state data specified.\n");
572
                return -1;
573
            }
574

    
575
            state_bits  = get_bits(gbp, 4);
576
            state_shift = get_bits(gbp, 4);
577

    
578
            /* TODO: Check validity of state data. */
579

    
580
            for (i = 0; i < order; i++)
581
                fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
582
        }
583
    }
584

    
585
    return 0;
586
}
587

    
588
/** Read parameters for primitive matrices. */
589

    
590
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
591
{
592
    SubStream *s = &m->substream[substr];
593
    unsigned int mat, ch;
594
    const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
595
                                     ? MAX_MATRICES_MLP
596
                                     : MAX_MATRICES_TRUEHD;
597

    
598
    if (m->matrix_changed++ > 1) {
599
        av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
600
        return -1;
601
    }
602

    
603
    s->num_primitive_matrices = get_bits(gbp, 4);
604

    
605
    if (s->num_primitive_matrices > max_primitive_matrices) {
606
        av_log(m->avctx, AV_LOG_ERROR,
607
               "Number of primitive matrices cannot be greater than %d.\n",
608
               max_primitive_matrices);
609
        return -1;
610
    }
611

    
612
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
613
        int frac_bits, max_chan;
614
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
615
        frac_bits             = get_bits(gbp, 4);
616
        s->lsb_bypass   [mat] = get_bits1(gbp);
617

    
618
        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
619
            av_log(m->avctx, AV_LOG_ERROR,
620
                    "Invalid channel %d specified as output from matrix.\n",
621
                    s->matrix_out_ch[mat]);
622
            return -1;
623
        }
624
        if (frac_bits > 14) {
625
            av_log(m->avctx, AV_LOG_ERROR,
626
                    "Too many fractional bits specified.\n");
627
            return -1;
628
        }
629

    
630
        max_chan = s->max_matrix_channel;
631
        if (!s->noise_type)
632
            max_chan+=2;
633

    
634
        for (ch = 0; ch <= max_chan; ch++) {
635
            int coeff_val = 0;
636
            if (get_bits1(gbp))
637
                coeff_val = get_sbits(gbp, frac_bits + 2);
638

    
639
            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
640
        }
641

    
642
        if (s->noise_type)
643
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
644
        else
645
            s->matrix_noise_shift[mat] = 0;
646
    }
647

    
648
    return 0;
649
}
650

    
651
/** Read channel parameters. */
652

    
653
static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
654
                               GetBitContext *gbp, unsigned int ch)
655
{
656
    SubStream *s = &m->substream[substr];
657
    ChannelParams *cp = &s->channel_params[ch];
658
    FilterParams *fir = &cp->filter_params[FIR];
659
    FilterParams *iir = &cp->filter_params[IIR];
660

    
661
    if (s->param_presence_flags & PARAM_FIR)
662
        if (get_bits1(gbp))
663
            if (read_filter_params(m, gbp, substr, ch, FIR) < 0)
664
                return -1;
665

    
666
    if (s->param_presence_flags & PARAM_IIR)
667
        if (get_bits1(gbp))
668
            if (read_filter_params(m, gbp, substr, ch, IIR) < 0)
669
                return -1;
670

    
671
    if (fir->order + iir->order > 8) {
672
        av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
673
        return -1;
674
    }
675

    
676
    if (fir->order && iir->order &&
677
        fir->shift != iir->shift) {
678
        av_log(m->avctx, AV_LOG_ERROR,
679
                "FIR and IIR filters must use the same precision.\n");
680
        return -1;
681
    }
682
    /* The FIR and IIR filters must have the same precision.
683
     * To simplify the filtering code, only the precision of the
684
     * FIR filter is considered. If only the IIR filter is employed,
685
     * the FIR filter precision is set to that of the IIR filter, so
686
     * that the filtering code can use it. */
687
    if (!fir->order && iir->order)
688
        fir->shift = iir->shift;
689

    
690
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
691
        if (get_bits1(gbp))
692
            cp->huff_offset = get_sbits(gbp, 15);
693

    
694
    cp->codebook  = get_bits(gbp, 2);
695
    cp->huff_lsbs = get_bits(gbp, 5);
696

    
697
    if (cp->huff_lsbs > 24) {
698
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
699
        return -1;
700
    }
701

    
702
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
703

    
704
    return 0;
705
}
706

    
707
/** Read decoding parameters that change more often than those in the restart
708
 *  header. */
709

    
710
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
711
                                unsigned int substr)
712
{
713
    SubStream *s = &m->substream[substr];
714
    unsigned int ch;
715

    
716
    if (s->param_presence_flags & PARAM_PRESENCE)
717
        if (get_bits1(gbp))
718
            s->param_presence_flags = get_bits(gbp, 8);
719

    
720
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
721
        if (get_bits1(gbp)) {
722
            s->blocksize = get_bits(gbp, 9);
723
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
724
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
725
                s->blocksize = 0;
726
                return -1;
727
            }
728
        }
729

    
730
    if (s->param_presence_flags & PARAM_MATRIX)
731
        if (get_bits1(gbp))
732
            if (read_matrix_params(m, substr, gbp) < 0)
733
                return -1;
734

    
735
    if (s->param_presence_flags & PARAM_OUTSHIFT)
736
        if (get_bits1(gbp))
737
            for (ch = 0; ch <= s->max_matrix_channel; ch++)
738
                s->output_shift[ch] = get_sbits(gbp, 4);
739

    
740
    if (s->param_presence_flags & PARAM_QUANTSTEP)
741
        if (get_bits1(gbp))
742
            for (ch = 0; ch <= s->max_channel; ch++) {
743
                ChannelParams *cp = &s->channel_params[ch];
744

    
745
                s->quant_step_size[ch] = get_bits(gbp, 4);
746

    
747
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
748
            }
749

    
750
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
751
        if (get_bits1(gbp))
752
            if (read_channel_params(m, substr, gbp, ch) < 0)
753
                return -1;
754

    
755
    return 0;
756
}
757

    
758
#define MSB_MASK(bits)  (-1u << bits)
759

    
760
/** Generate PCM samples using the prediction filters and residual values
761
 *  read from the data stream, and update the filter state. */
762

    
763
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
764
                           unsigned int channel)
765
{
766
    SubStream *s = &m->substream[substr];
767
    const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
768
    int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
769
    int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
770
    int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
771
    FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
772
    FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
773
    unsigned int filter_shift = fir->shift;
774
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
775

    
776
    memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
777
    memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
778

    
779
    m->dsp.mlp_filter_channel(firbuf, fircoeff,
780
                              fir->order, iir->order,
781
                              filter_shift, mask, s->blocksize,
782
                              &m->sample_buffer[s->blockpos][channel]);
783

    
784
    memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
785
    memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
786
}
787

    
788
/** Read a block of PCM residual data (or actual if no filtering active). */
789

    
790
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
791
                           unsigned int substr)
792
{
793
    SubStream *s = &m->substream[substr];
794
    unsigned int i, ch, expected_stream_pos = 0;
795

    
796
    if (s->data_check_present) {
797
        expected_stream_pos  = get_bits_count(gbp);
798
        expected_stream_pos += get_bits(gbp, 16);
799
        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
800
               "we have not tested yet. %s\n", sample_message);
801
    }
802

    
803
    if (s->blockpos + s->blocksize > m->access_unit_size) {
804
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
805
        return -1;
806
    }
807

    
808
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
809
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
810

    
811
    for (i = 0; i < s->blocksize; i++)
812
        if (read_huff_channels(m, gbp, substr, i) < 0)
813
            return -1;
814

    
815
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
816
        filter_channel(m, substr, ch);
817

    
818
    s->blockpos += s->blocksize;
819

    
820
    if (s->data_check_present) {
821
        if (get_bits_count(gbp) != expected_stream_pos)
822
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
823
        skip_bits(gbp, 8);
824
    }
825

    
826
    return 0;
827
}
828

    
829
/** Data table used for TrueHD noise generation function. */
830

    
831
static const int8_t noise_table[256] = {
832
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
833
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
834
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
835
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
836
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
837
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
838
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
839
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
840
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
841
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
842
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
843
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
844
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
845
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
846
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
847
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
848
};
849

    
850
/** Noise generation functions.
851
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
852
 *  sequence generators, used to generate noise data which is used when the
853
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
854
 *  to compression, or just obfuscate the decoder. Are they for some kind of
855
 *  dithering? */
856

    
857
/** Generate two channels of noise, used in the matrix when
858
 *  restart sync word == 0x31ea. */
859

    
860
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
861
{
862
    SubStream *s = &m->substream[substr];
863
    unsigned int i;
864
    uint32_t seed = s->noisegen_seed;
865
    unsigned int maxchan = s->max_matrix_channel;
866

    
867
    for (i = 0; i < s->blockpos; i++) {
868
        uint16_t seed_shr7 = seed >> 7;
869
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
870
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
871

    
872
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
873
    }
874

    
875
    s->noisegen_seed = seed;
876
}
877

    
878
/** Generate a block of noise, used when restart sync word == 0x31eb. */
879

    
880
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
881
{
882
    SubStream *s = &m->substream[substr];
883
    unsigned int i;
884
    uint32_t seed = s->noisegen_seed;
885

    
886
    for (i = 0; i < m->access_unit_size_pow2; i++) {
887
        uint8_t seed_shr15 = seed >> 15;
888
        m->noise_buffer[i] = noise_table[seed_shr15];
889
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
890
    }
891

    
892
    s->noisegen_seed = seed;
893
}
894

    
895

    
896
/** Apply the channel matrices in turn to reconstruct the original audio
897
 *  samples. */
898

    
899
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
900
{
901
    SubStream *s = &m->substream[substr];
902
    unsigned int mat, src_ch, i;
903
    unsigned int maxchan;
904

    
905
    maxchan = s->max_matrix_channel;
906
    if (!s->noise_type) {
907
        generate_2_noise_channels(m, substr);
908
        maxchan += 2;
909
    } else {
910
        fill_noise_buffer(m, substr);
911
    }
912

    
913
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
914
        int matrix_noise_shift = s->matrix_noise_shift[mat];
915
        unsigned int dest_ch = s->matrix_out_ch[mat];
916
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
917
        int32_t *coeffs = s->matrix_coeff[mat];
918
        int index  = s->num_primitive_matrices - mat;
919
        int index2 = 2 * index + 1;
920

    
921
        /* TODO: DSPContext? */
922

    
923
        for (i = 0; i < s->blockpos; i++) {
924
            int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
925
            int32_t *samples = m->sample_buffer[i];
926
            int64_t accum = 0;
927

    
928
            for (src_ch = 0; src_ch <= maxchan; src_ch++)
929
                accum += (int64_t) samples[src_ch] * coeffs[src_ch];
930

    
931
            if (matrix_noise_shift) {
932
                index &= m->access_unit_size_pow2 - 1;
933
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
934
                index += index2;
935
            }
936

    
937
            samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
938
        }
939
    }
940
}
941

    
942
/** Write the audio data into the output buffer. */
943

    
944
static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
945
                                uint8_t *data, unsigned int *data_size, int is32)
946
{
947
    SubStream *s = &m->substream[substr];
948
    unsigned int i, out_ch = 0;
949
    int32_t *data_32 = (int32_t*) data;
950
    int16_t *data_16 = (int16_t*) data;
951

    
952
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
953
        return -1;
954

    
955
    for (i = 0; i < s->blockpos; i++) {
956
        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
957
            int mat_ch = s->ch_assign[out_ch];
958
            int32_t sample = m->sample_buffer[i][mat_ch]
959
                          << s->output_shift[mat_ch];
960
            s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
961
            if (is32) *data_32++ = sample << 8;
962
            else      *data_16++ = sample >> 8;
963
        }
964
    }
965

    
966
    *data_size = i * out_ch * (is32 ? 4 : 2);
967

    
968
    return 0;
969
}
970

    
971
static int output_data(MLPDecodeContext *m, unsigned int substr,
972
                       uint8_t *data, unsigned int *data_size)
973
{
974
    if (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32)
975
        return output_data_internal(m, substr, data, data_size, 1);
976
    else
977
        return output_data_internal(m, substr, data, data_size, 0);
978
}
979

    
980

    
981
/** Read an access unit from the stream.
982
 *  @return negative on error, 0 if not enough data is present in the input stream,
983
 *  otherwise the number of bytes consumed. */
984

    
985
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
986
                            AVPacket *avpkt)
987
{
988
    const uint8_t *buf = avpkt->data;
989
    int buf_size = avpkt->size;
990
    MLPDecodeContext *m = avctx->priv_data;
991
    GetBitContext gb;
992
    unsigned int length, substr;
993
    unsigned int substream_start;
994
    unsigned int header_size = 4;
995
    unsigned int substr_header_size = 0;
996
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
997
    uint16_t substream_data_len[MAX_SUBSTREAMS];
998
    uint8_t parity_bits;
999

    
1000
    if (buf_size < 4)
1001
        return 0;
1002

    
1003
    length = (AV_RB16(buf) & 0xfff) * 2;
1004

    
1005
    if (length < 4 || length > buf_size)
1006
        return -1;
1007

    
1008
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1009

    
1010
    m->is_major_sync_unit = 0;
1011
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1012
        if (read_major_sync(m, &gb) < 0)
1013
            goto error;
1014
        m->is_major_sync_unit = 1;
1015
        header_size += 28;
1016
    }
1017

    
1018
    if (!m->params_valid) {
1019
        av_log(m->avctx, AV_LOG_WARNING,
1020
               "Stream parameters not seen; skipping frame.\n");
1021
        *data_size = 0;
1022
        return length;
1023
    }
1024

    
1025
    substream_start = 0;
1026

    
1027
    for (substr = 0; substr < m->num_substreams; substr++) {
1028
        int extraword_present, checkdata_present, end, nonrestart_substr;
1029

    
1030
        extraword_present = get_bits1(&gb);
1031
        nonrestart_substr = get_bits1(&gb);
1032
        checkdata_present = get_bits1(&gb);
1033
        skip_bits1(&gb);
1034

    
1035
        end = get_bits(&gb, 12) * 2;
1036

    
1037
        substr_header_size += 2;
1038

    
1039
        if (extraword_present) {
1040
            if (m->avctx->codec_id == CODEC_ID_MLP) {
1041
                av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1042
                goto error;
1043
            }
1044
            skip_bits(&gb, 16);
1045
            substr_header_size += 2;
1046
        }
1047

    
1048
        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1049
            av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1050
            goto error;
1051
        }
1052

    
1053
        if (end + header_size + substr_header_size > length) {
1054
            av_log(m->avctx, AV_LOG_ERROR,
1055
                   "Indicated length of substream %d data goes off end of "
1056
                   "packet.\n", substr);
1057
            end = length - header_size - substr_header_size;
1058
        }
1059

    
1060
        if (end < substream_start) {
1061
            av_log(avctx, AV_LOG_ERROR,
1062
                   "Indicated end offset of substream %d data "
1063
                   "is smaller than calculated start offset.\n",
1064
                   substr);
1065
            goto error;
1066
        }
1067

    
1068
        if (substr > m->max_decoded_substream)
1069
            continue;
1070

    
1071
        substream_parity_present[substr] = checkdata_present;
1072
        substream_data_len[substr] = end - substream_start;
1073
        substream_start = end;
1074
    }
1075

    
1076
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
1077
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1078

    
1079
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1080
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1081
        goto error;
1082
    }
1083

    
1084
    buf += header_size + substr_header_size;
1085

    
1086
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1087
        SubStream *s = &m->substream[substr];
1088
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1089

    
1090
        m->matrix_changed = 0;
1091
        memset(m->filter_changed, 0, sizeof(m->filter_changed));
1092

    
1093
        s->blockpos = 0;
1094
        do {
1095
            if (get_bits1(&gb)) {
1096
                if (get_bits1(&gb)) {
1097
                    /* A restart header should be present. */
1098
                    if (read_restart_header(m, &gb, buf, substr) < 0)
1099
                        goto next_substr;
1100
                    s->restart_seen = 1;
1101
                }
1102

    
1103
                if (!s->restart_seen)
1104
                    goto next_substr;
1105
                if (read_decoding_params(m, &gb, substr) < 0)
1106
                    goto next_substr;
1107
            }
1108

    
1109
            if (!s->restart_seen)
1110
                goto next_substr;
1111

    
1112
            if (read_block_data(m, &gb, substr) < 0)
1113
                return -1;
1114

    
1115
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1116
                goto substream_length_mismatch;
1117

    
1118
        } while (!get_bits1(&gb));
1119

    
1120
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1121

    
1122
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1123
            int shorten_by;
1124

    
1125
            if (get_bits(&gb, 16) != 0xD234)
1126
                return -1;
1127

    
1128
            shorten_by = get_bits(&gb, 16);
1129
            if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1130
                s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1131
            else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
1132
                return -1;
1133

    
1134
            if (substr == m->max_decoded_substream)
1135
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1136
        }
1137

    
1138
        if (substream_parity_present[substr]) {
1139
            uint8_t parity, checksum;
1140

    
1141
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1142
                goto substream_length_mismatch;
1143

    
1144
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1145
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1146

    
1147
            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1148
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1149
            if ( get_bits(&gb, 8)           != checksum)
1150
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1151
        }
1152

    
1153
        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1154
            goto substream_length_mismatch;
1155

    
1156
next_substr:
1157
        if (!s->restart_seen)
1158
            av_log(m->avctx, AV_LOG_ERROR,
1159
                   "No restart header present in substream %d.\n", substr);
1160

    
1161
        buf += substream_data_len[substr];
1162
    }
1163

    
1164
    rematrix_channels(m, m->max_decoded_substream);
1165

    
1166
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1167
        return -1;
1168

    
1169
    return length;
1170

    
1171
substream_length_mismatch:
1172
    av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1173
    return -1;
1174

    
1175
error:
1176
    m->params_valid = 0;
1177
    return -1;
1178
}
1179

    
1180
AVCodec ff_mlp_decoder = {
1181
    "mlp",
1182
    AVMEDIA_TYPE_AUDIO,
1183
    CODEC_ID_MLP,
1184
    sizeof(MLPDecodeContext),
1185
    mlp_decode_init,
1186
    NULL,
1187
    NULL,
1188
    read_access_unit,
1189
    .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1190
};
1191

    
1192
#if CONFIG_TRUEHD_DECODER
1193
AVCodec ff_truehd_decoder = {
1194
    "truehd",
1195
    AVMEDIA_TYPE_AUDIO,
1196
    CODEC_ID_TRUEHD,
1197
    sizeof(MLPDecodeContext),
1198
    mlp_decode_init,
1199
    NULL,
1200
    NULL,
1201
    read_access_unit,
1202
    .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1203
};
1204
#endif /* CONFIG_TRUEHD_DECODER */