Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ 2912e87a

History | View | Annotate | Download (38.2 KB)

1
/*
2
 * MLP decoder
3
 * Copyright (c) 2007-2008 Ian Caulfield
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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://libav.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
    //! number of PCM samples contained in each frame
137
    int         access_unit_size;
138
    //! next power of two above the number of samples in each frame
139
    int         access_unit_size_pow2;
140

    
141
    SubStream   substream[MAX_SUBSTREAMS];
142

    
143
    int         matrix_changed;
144
    int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
145

    
146
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
147
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
148
    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
149

    
150
    DSPContext  dsp;
151
} MLPDecodeContext;
152

    
153
static VLC huff_vlc[3];
154

    
155
/** Initialize static data, constant between all invocations of the codec. */
156

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

    
171
    ff_mlp_init_crc();
172
}
173

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

    
183
    if (cp->codebook > 0)
184
        sign_huff_offset -= 7 << lsb_bits;
185

    
186
    if (sign_shift >= 0)
187
        sign_huff_offset -= 1 << sign_shift;
188

    
189
    return sign_huff_offset;
190
}
191

    
192
/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
193
 *  and plain LSBs. */
194

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

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

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

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

    
216
        if (result < 0)
217
            return -1;
218

    
219
        if (lsb_bits > 0)
220
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
221

    
222
        result  += cp->sign_huff_offset;
223
        result <<= quant_step_size;
224

    
225
        m->sample_buffer[pos + s->blockpos][channel] = result;
226
    }
227

    
228
    return 0;
229
}
230

    
231
static av_cold int mlp_decode_init(AVCodecContext *avctx)
232
{
233
    MLPDecodeContext *m = avctx->priv_data;
234
    int substr;
235

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

    
242
    return 0;
243
}
244

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

    
250
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
251
{
252
    MLPHeaderInfo mh;
253
    int substr;
254

    
255
    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
256
        return -1;
257

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

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

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

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

    
310
    m->access_unit_size      = mh.access_unit_size;
311
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;
312

    
313
    m->num_substreams        = mh.num_substreams;
314
    m->max_decoded_substream = m->num_substreams - 1;
315

    
316
    m->avctx->sample_rate    = mh.group1_samplerate;
317
    m->avctx->frame_size     = mh.access_unit_size;
318

    
319
    m->avctx->bits_per_raw_sample = mh.group1_bits;
320
    if (mh.group1_bits > 16)
321
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
322
    else
323
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
324

    
325
    m->params_valid = 1;
326
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
327
        m->substream[substr].restart_seen = 0;
328

    
329
    return 0;
330
}
331

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

    
336
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
337
                               const uint8_t *buf, unsigned int substr)
338
{
339
    SubStream *s = &m->substream[substr];
340
    unsigned int ch;
341
    int sync_word, tmp;
342
    uint8_t checksum;
343
    uint8_t lossless_check;
344
    int start_count = get_bits_count(gbp);
345
    const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
346
                                 ? MAX_MATRIX_CHANNEL_MLP
347
                                 : MAX_MATRIX_CHANNEL_TRUEHD;
348

    
349
    sync_word = get_bits(gbp, 13);
350

    
351
    if (sync_word != 0x31ea >> 1) {
352
        av_log(m->avctx, AV_LOG_ERROR,
353
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
354
        return -1;
355
    }
356

    
357
    s->noise_type = get_bits1(gbp);
358

    
359
    if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
360
        av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
361
        return -1;
362
    }
363

    
364
    skip_bits(gbp, 16); /* Output timestamp */
365

    
366
    s->min_channel        = get_bits(gbp, 4);
367
    s->max_channel        = get_bits(gbp, 4);
368
    s->max_matrix_channel = get_bits(gbp, 4);
369

    
370
    if (s->max_matrix_channel > max_matrix_channel) {
371
        av_log(m->avctx, AV_LOG_ERROR,
372
               "Max matrix channel cannot be greater than %d.\n",
373
               max_matrix_channel);
374
        return -1;
375
    }
376

    
377
    if (s->max_channel != s->max_matrix_channel) {
378
        av_log(m->avctx, AV_LOG_ERROR,
379
               "Max channel must be equal max matrix channel.\n");
380
        return -1;
381
    }
382

    
383
    /* This should happen for TrueHD streams with >6 channels and MLP's noise
384
     * type. It is not yet known if this is allowed. */
385
    if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
386
        av_log(m->avctx, AV_LOG_ERROR,
387
               "Number of channels %d is larger than the maximum supported "
388
               "by the decoder. %s\n", s->max_channel+2, sample_message);
389
        return -1;
390
    }
391

    
392
    if (s->min_channel > s->max_channel) {
393
        av_log(m->avctx, AV_LOG_ERROR,
394
               "Substream min channel cannot be greater than max channel.\n");
395
        return -1;
396
    }
397

    
398
    if (m->avctx->request_channels > 0
399
        && s->max_channel + 1 >= m->avctx->request_channels
400
        && substr < m->max_decoded_substream) {
401
        av_log(m->avctx, AV_LOG_DEBUG,
402
               "Extracting %d channel downmix from substream %d. "
403
               "Further substreams will be skipped.\n",
404
               s->max_channel + 1, substr);
405
        m->max_decoded_substream = substr;
406
    }
407

    
408
    s->noise_shift   = get_bits(gbp,  4);
409
    s->noisegen_seed = get_bits(gbp, 23);
410

    
411
    skip_bits(gbp, 19);
412

    
413
    s->data_check_present = get_bits1(gbp);
414
    lossless_check = get_bits(gbp, 8);
415
    if (substr == m->max_decoded_substream
416
        && s->lossless_check_data != 0xffffffff) {
417
        tmp = xor_32_to_8(s->lossless_check_data);
418
        if (tmp != lossless_check)
419
            av_log(m->avctx, AV_LOG_WARNING,
420
                   "Lossless check failed - expected %02x, calculated %02x.\n",
421
                   lossless_check, tmp);
422
    }
423

    
424
    skip_bits(gbp, 16);
425

    
426
    memset(s->ch_assign, 0, sizeof(s->ch_assign));
427

    
428
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
429
        int ch_assign = get_bits(gbp, 6);
430
        if (ch_assign > s->max_matrix_channel) {
431
            av_log(m->avctx, AV_LOG_ERROR,
432
                   "Assignment of matrix channel %d to invalid output channel %d. %s\n",
433
                   ch, ch_assign, sample_message);
434
            return -1;
435
        }
436
        s->ch_assign[ch_assign] = ch;
437
    }
438

    
439
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
440

    
441
    if (checksum != get_bits(gbp, 8))
442
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
443

    
444
    /* Set default decoding parameters. */
445
    s->param_presence_flags   = 0xff;
446
    s->num_primitive_matrices = 0;
447
    s->blocksize              = 8;
448
    s->lossless_check_data    = 0;
449

    
450
    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
451
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
452

    
453
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
454
        ChannelParams *cp = &s->channel_params[ch];
455
        cp->filter_params[FIR].order = 0;
456
        cp->filter_params[IIR].order = 0;
457
        cp->filter_params[FIR].shift = 0;
458
        cp->filter_params[IIR].shift = 0;
459

    
460
        /* Default audio coding is 24-bit raw PCM. */
461
        cp->huff_offset      = 0;
462
        cp->sign_huff_offset = (-1) << 23;
463
        cp->codebook         = 0;
464
        cp->huff_lsbs        = 24;
465
    }
466

    
467
    if (substr == m->max_decoded_substream)
468
        m->avctx->channels = s->max_matrix_channel + 1;
469

    
470
    return 0;
471
}
472

    
473
/** Read parameters for one of the prediction filters. */
474

    
475
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
476
                              unsigned int substr, unsigned int channel,
477
                              unsigned int filter)
478
{
479
    SubStream *s = &m->substream[substr];
480
    FilterParams *fp = &s->channel_params[channel].filter_params[filter];
481
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
482
    const char fchar = filter ? 'I' : 'F';
483
    int i, order;
484

    
485
    // Filter is 0 for FIR, 1 for IIR.
486
    assert(filter < 2);
487

    
488
    if (m->filter_changed[channel][filter]++ > 1) {
489
        av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
490
        return -1;
491
    }
492

    
493
    order = get_bits(gbp, 4);
494
    if (order > max_order) {
495
        av_log(m->avctx, AV_LOG_ERROR,
496
               "%cIR filter order %d is greater than maximum %d.\n",
497
               fchar, order, max_order);
498
        return -1;
499
    }
500
    fp->order = order;
501

    
502
    if (order > 0) {
503
        int32_t *fcoeff = s->channel_params[channel].coeff[filter];
504
        int coeff_bits, coeff_shift;
505

    
506
        fp->shift = get_bits(gbp, 4);
507

    
508
        coeff_bits  = get_bits(gbp, 5);
509
        coeff_shift = get_bits(gbp, 3);
510
        if (coeff_bits < 1 || coeff_bits > 16) {
511
            av_log(m->avctx, AV_LOG_ERROR,
512
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
513
                   fchar);
514
            return -1;
515
        }
516
        if (coeff_bits + coeff_shift > 16) {
517
            av_log(m->avctx, AV_LOG_ERROR,
518
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
519
                   fchar);
520
            return -1;
521
        }
522

    
523
        for (i = 0; i < order; i++)
524
            fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
525

    
526
        if (get_bits1(gbp)) {
527
            int state_bits, state_shift;
528

    
529
            if (filter == FIR) {
530
                av_log(m->avctx, AV_LOG_ERROR,
531
                       "FIR filter has state data specified.\n");
532
                return -1;
533
            }
534

    
535
            state_bits  = get_bits(gbp, 4);
536
            state_shift = get_bits(gbp, 4);
537

    
538
            /* TODO: Check validity of state data. */
539

    
540
            for (i = 0; i < order; i++)
541
                fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
542
        }
543
    }
544

    
545
    return 0;
546
}
547

    
548
/** Read parameters for primitive matrices. */
549

    
550
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
551
{
552
    SubStream *s = &m->substream[substr];
553
    unsigned int mat, ch;
554
    const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
555
                                     ? MAX_MATRICES_MLP
556
                                     : MAX_MATRICES_TRUEHD;
557

    
558
    if (m->matrix_changed++ > 1) {
559
        av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
560
        return -1;
561
    }
562

    
563
    s->num_primitive_matrices = get_bits(gbp, 4);
564

    
565
    if (s->num_primitive_matrices > max_primitive_matrices) {
566
        av_log(m->avctx, AV_LOG_ERROR,
567
               "Number of primitive matrices cannot be greater than %d.\n",
568
               max_primitive_matrices);
569
        return -1;
570
    }
571

    
572
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
573
        int frac_bits, max_chan;
574
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
575
        frac_bits             = get_bits(gbp, 4);
576
        s->lsb_bypass   [mat] = get_bits1(gbp);
577

    
578
        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
579
            av_log(m->avctx, AV_LOG_ERROR,
580
                    "Invalid channel %d specified as output from matrix.\n",
581
                    s->matrix_out_ch[mat]);
582
            return -1;
583
        }
584
        if (frac_bits > 14) {
585
            av_log(m->avctx, AV_LOG_ERROR,
586
                    "Too many fractional bits specified.\n");
587
            return -1;
588
        }
589

    
590
        max_chan = s->max_matrix_channel;
591
        if (!s->noise_type)
592
            max_chan+=2;
593

    
594
        for (ch = 0; ch <= max_chan; ch++) {
595
            int coeff_val = 0;
596
            if (get_bits1(gbp))
597
                coeff_val = get_sbits(gbp, frac_bits + 2);
598

    
599
            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
600
        }
601

    
602
        if (s->noise_type)
603
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
604
        else
605
            s->matrix_noise_shift[mat] = 0;
606
    }
607

    
608
    return 0;
609
}
610

    
611
/** Read channel parameters. */
612

    
613
static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
614
                               GetBitContext *gbp, unsigned int ch)
615
{
616
    SubStream *s = &m->substream[substr];
617
    ChannelParams *cp = &s->channel_params[ch];
618
    FilterParams *fir = &cp->filter_params[FIR];
619
    FilterParams *iir = &cp->filter_params[IIR];
620

    
621
    if (s->param_presence_flags & PARAM_FIR)
622
        if (get_bits1(gbp))
623
            if (read_filter_params(m, gbp, substr, ch, FIR) < 0)
624
                return -1;
625

    
626
    if (s->param_presence_flags & PARAM_IIR)
627
        if (get_bits1(gbp))
628
            if (read_filter_params(m, gbp, substr, ch, IIR) < 0)
629
                return -1;
630

    
631
    if (fir->order + iir->order > 8) {
632
        av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
633
        return -1;
634
    }
635

    
636
    if (fir->order && iir->order &&
637
        fir->shift != iir->shift) {
638
        av_log(m->avctx, AV_LOG_ERROR,
639
                "FIR and IIR filters must use the same precision.\n");
640
        return -1;
641
    }
642
    /* The FIR and IIR filters must have the same precision.
643
     * To simplify the filtering code, only the precision of the
644
     * FIR filter is considered. If only the IIR filter is employed,
645
     * the FIR filter precision is set to that of the IIR filter, so
646
     * that the filtering code can use it. */
647
    if (!fir->order && iir->order)
648
        fir->shift = iir->shift;
649

    
650
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
651
        if (get_bits1(gbp))
652
            cp->huff_offset = get_sbits(gbp, 15);
653

    
654
    cp->codebook  = get_bits(gbp, 2);
655
    cp->huff_lsbs = get_bits(gbp, 5);
656

    
657
    if (cp->huff_lsbs > 24) {
658
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
659
        return -1;
660
    }
661

    
662
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
663

    
664
    return 0;
665
}
666

    
667
/** Read decoding parameters that change more often than those in the restart
668
 *  header. */
669

    
670
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
671
                                unsigned int substr)
672
{
673
    SubStream *s = &m->substream[substr];
674
    unsigned int ch;
675

    
676
    if (s->param_presence_flags & PARAM_PRESENCE)
677
        if (get_bits1(gbp))
678
            s->param_presence_flags = get_bits(gbp, 8);
679

    
680
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
681
        if (get_bits1(gbp)) {
682
            s->blocksize = get_bits(gbp, 9);
683
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
684
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
685
                s->blocksize = 0;
686
                return -1;
687
            }
688
        }
689

    
690
    if (s->param_presence_flags & PARAM_MATRIX)
691
        if (get_bits1(gbp))
692
            if (read_matrix_params(m, substr, gbp) < 0)
693
                return -1;
694

    
695
    if (s->param_presence_flags & PARAM_OUTSHIFT)
696
        if (get_bits1(gbp))
697
            for (ch = 0; ch <= s->max_matrix_channel; ch++)
698
                s->output_shift[ch] = get_sbits(gbp, 4);
699

    
700
    if (s->param_presence_flags & PARAM_QUANTSTEP)
701
        if (get_bits1(gbp))
702
            for (ch = 0; ch <= s->max_channel; ch++) {
703
                ChannelParams *cp = &s->channel_params[ch];
704

    
705
                s->quant_step_size[ch] = get_bits(gbp, 4);
706

    
707
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
708
            }
709

    
710
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
711
        if (get_bits1(gbp))
712
            if (read_channel_params(m, substr, gbp, ch) < 0)
713
                return -1;
714

    
715
    return 0;
716
}
717

    
718
#define MSB_MASK(bits)  (-1u << bits)
719

    
720
/** Generate PCM samples using the prediction filters and residual values
721
 *  read from the data stream, and update the filter state. */
722

    
723
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
724
                           unsigned int channel)
725
{
726
    SubStream *s = &m->substream[substr];
727
    const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
728
    int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
729
    int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
730
    int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
731
    FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
732
    FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
733
    unsigned int filter_shift = fir->shift;
734
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
735

    
736
    memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
737
    memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
738

    
739
    m->dsp.mlp_filter_channel(firbuf, fircoeff,
740
                              fir->order, iir->order,
741
                              filter_shift, mask, s->blocksize,
742
                              &m->sample_buffer[s->blockpos][channel]);
743

    
744
    memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
745
    memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
746
}
747

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

    
750
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
751
                           unsigned int substr)
752
{
753
    SubStream *s = &m->substream[substr];
754
    unsigned int i, ch, expected_stream_pos = 0;
755

    
756
    if (s->data_check_present) {
757
        expected_stream_pos  = get_bits_count(gbp);
758
        expected_stream_pos += get_bits(gbp, 16);
759
        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
760
               "we have not tested yet. %s\n", sample_message);
761
    }
762

    
763
    if (s->blockpos + s->blocksize > m->access_unit_size) {
764
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
765
        return -1;
766
    }
767

    
768
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
769
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
770

    
771
    for (i = 0; i < s->blocksize; i++)
772
        if (read_huff_channels(m, gbp, substr, i) < 0)
773
            return -1;
774

    
775
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
776
        filter_channel(m, substr, ch);
777

    
778
    s->blockpos += s->blocksize;
779

    
780
    if (s->data_check_present) {
781
        if (get_bits_count(gbp) != expected_stream_pos)
782
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
783
        skip_bits(gbp, 8);
784
    }
785

    
786
    return 0;
787
}
788

    
789
/** Data table used for TrueHD noise generation function. */
790

    
791
static const int8_t noise_table[256] = {
792
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
793
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
794
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
795
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
796
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
797
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
798
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
799
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
800
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
801
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
802
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
803
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
804
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
805
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
806
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
807
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
808
};
809

    
810
/** Noise generation functions.
811
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
812
 *  sequence generators, used to generate noise data which is used when the
813
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
814
 *  to compression, or just obfuscate the decoder. Are they for some kind of
815
 *  dithering? */
816

    
817
/** Generate two channels of noise, used in the matrix when
818
 *  restart sync word == 0x31ea. */
819

    
820
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
821
{
822
    SubStream *s = &m->substream[substr];
823
    unsigned int i;
824
    uint32_t seed = s->noisegen_seed;
825
    unsigned int maxchan = s->max_matrix_channel;
826

    
827
    for (i = 0; i < s->blockpos; i++) {
828
        uint16_t seed_shr7 = seed >> 7;
829
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
830
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
831

    
832
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
833
    }
834

    
835
    s->noisegen_seed = seed;
836
}
837

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

    
840
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
841
{
842
    SubStream *s = &m->substream[substr];
843
    unsigned int i;
844
    uint32_t seed = s->noisegen_seed;
845

    
846
    for (i = 0; i < m->access_unit_size_pow2; i++) {
847
        uint8_t seed_shr15 = seed >> 15;
848
        m->noise_buffer[i] = noise_table[seed_shr15];
849
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
850
    }
851

    
852
    s->noisegen_seed = seed;
853
}
854

    
855

    
856
/** Apply the channel matrices in turn to reconstruct the original audio
857
 *  samples. */
858

    
859
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
860
{
861
    SubStream *s = &m->substream[substr];
862
    unsigned int mat, src_ch, i;
863
    unsigned int maxchan;
864

    
865
    maxchan = s->max_matrix_channel;
866
    if (!s->noise_type) {
867
        generate_2_noise_channels(m, substr);
868
        maxchan += 2;
869
    } else {
870
        fill_noise_buffer(m, substr);
871
    }
872

    
873
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
874
        int matrix_noise_shift = s->matrix_noise_shift[mat];
875
        unsigned int dest_ch = s->matrix_out_ch[mat];
876
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
877
        int32_t *coeffs = s->matrix_coeff[mat];
878
        int index  = s->num_primitive_matrices - mat;
879
        int index2 = 2 * index + 1;
880

    
881
        /* TODO: DSPContext? */
882

    
883
        for (i = 0; i < s->blockpos; i++) {
884
            int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
885
            int32_t *samples = m->sample_buffer[i];
886
            int64_t accum = 0;
887

    
888
            for (src_ch = 0; src_ch <= maxchan; src_ch++)
889
                accum += (int64_t) samples[src_ch] * coeffs[src_ch];
890

    
891
            if (matrix_noise_shift) {
892
                index &= m->access_unit_size_pow2 - 1;
893
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
894
                index += index2;
895
            }
896

    
897
            samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
898
        }
899
    }
900
}
901

    
902
/** Write the audio data into the output buffer. */
903

    
904
static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
905
                                uint8_t *data, unsigned int *data_size, int is32)
906
{
907
    SubStream *s = &m->substream[substr];
908
    unsigned int i, out_ch = 0;
909
    int32_t *data_32 = (int32_t*) data;
910
    int16_t *data_16 = (int16_t*) data;
911

    
912
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
913
        return -1;
914

    
915
    for (i = 0; i < s->blockpos; i++) {
916
        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
917
            int mat_ch = s->ch_assign[out_ch];
918
            int32_t sample = m->sample_buffer[i][mat_ch]
919
                          << s->output_shift[mat_ch];
920
            s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
921
            if (is32) *data_32++ = sample << 8;
922
            else      *data_16++ = sample >> 8;
923
        }
924
    }
925

    
926
    *data_size = i * out_ch * (is32 ? 4 : 2);
927

    
928
    return 0;
929
}
930

    
931
static int output_data(MLPDecodeContext *m, unsigned int substr,
932
                       uint8_t *data, unsigned int *data_size)
933
{
934
    if (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32)
935
        return output_data_internal(m, substr, data, data_size, 1);
936
    else
937
        return output_data_internal(m, substr, data, data_size, 0);
938
}
939

    
940

    
941
/** Read an access unit from the stream.
942
 *  @return negative on error, 0 if not enough data is present in the input stream,
943
 *  otherwise the number of bytes consumed. */
944

    
945
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
946
                            AVPacket *avpkt)
947
{
948
    const uint8_t *buf = avpkt->data;
949
    int buf_size = avpkt->size;
950
    MLPDecodeContext *m = avctx->priv_data;
951
    GetBitContext gb;
952
    unsigned int length, substr;
953
    unsigned int substream_start;
954
    unsigned int header_size = 4;
955
    unsigned int substr_header_size = 0;
956
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
957
    uint16_t substream_data_len[MAX_SUBSTREAMS];
958
    uint8_t parity_bits;
959

    
960
    if (buf_size < 4)
961
        return 0;
962

    
963
    length = (AV_RB16(buf) & 0xfff) * 2;
964

    
965
    if (length < 4 || length > buf_size)
966
        return -1;
967

    
968
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
969

    
970
    m->is_major_sync_unit = 0;
971
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
972
        if (read_major_sync(m, &gb) < 0)
973
            goto error;
974
        m->is_major_sync_unit = 1;
975
        header_size += 28;
976
    }
977

    
978
    if (!m->params_valid) {
979
        av_log(m->avctx, AV_LOG_WARNING,
980
               "Stream parameters not seen; skipping frame.\n");
981
        *data_size = 0;
982
        return length;
983
    }
984

    
985
    substream_start = 0;
986

    
987
    for (substr = 0; substr < m->num_substreams; substr++) {
988
        int extraword_present, checkdata_present, end, nonrestart_substr;
989

    
990
        extraword_present = get_bits1(&gb);
991
        nonrestart_substr = get_bits1(&gb);
992
        checkdata_present = get_bits1(&gb);
993
        skip_bits1(&gb);
994

    
995
        end = get_bits(&gb, 12) * 2;
996

    
997
        substr_header_size += 2;
998

    
999
        if (extraword_present) {
1000
            if (m->avctx->codec_id == CODEC_ID_MLP) {
1001
                av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1002
                goto error;
1003
            }
1004
            skip_bits(&gb, 16);
1005
            substr_header_size += 2;
1006
        }
1007

    
1008
        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1009
            av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1010
            goto error;
1011
        }
1012

    
1013
        if (end + header_size + substr_header_size > length) {
1014
            av_log(m->avctx, AV_LOG_ERROR,
1015
                   "Indicated length of substream %d data goes off end of "
1016
                   "packet.\n", substr);
1017
            end = length - header_size - substr_header_size;
1018
        }
1019

    
1020
        if (end < substream_start) {
1021
            av_log(avctx, AV_LOG_ERROR,
1022
                   "Indicated end offset of substream %d data "
1023
                   "is smaller than calculated start offset.\n",
1024
                   substr);
1025
            goto error;
1026
        }
1027

    
1028
        if (substr > m->max_decoded_substream)
1029
            continue;
1030

    
1031
        substream_parity_present[substr] = checkdata_present;
1032
        substream_data_len[substr] = end - substream_start;
1033
        substream_start = end;
1034
    }
1035

    
1036
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
1037
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1038

    
1039
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1040
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1041
        goto error;
1042
    }
1043

    
1044
    buf += header_size + substr_header_size;
1045

    
1046
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1047
        SubStream *s = &m->substream[substr];
1048
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1049

    
1050
        m->matrix_changed = 0;
1051
        memset(m->filter_changed, 0, sizeof(m->filter_changed));
1052

    
1053
        s->blockpos = 0;
1054
        do {
1055
            if (get_bits1(&gb)) {
1056
                if (get_bits1(&gb)) {
1057
                    /* A restart header should be present. */
1058
                    if (read_restart_header(m, &gb, buf, substr) < 0)
1059
                        goto next_substr;
1060
                    s->restart_seen = 1;
1061
                }
1062

    
1063
                if (!s->restart_seen)
1064
                    goto next_substr;
1065
                if (read_decoding_params(m, &gb, substr) < 0)
1066
                    goto next_substr;
1067
            }
1068

    
1069
            if (!s->restart_seen)
1070
                goto next_substr;
1071

    
1072
            if (read_block_data(m, &gb, substr) < 0)
1073
                return -1;
1074

    
1075
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1076
                goto substream_length_mismatch;
1077

    
1078
        } while (!get_bits1(&gb));
1079

    
1080
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1081

    
1082
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1083
            int shorten_by;
1084

    
1085
            if (get_bits(&gb, 16) != 0xD234)
1086
                return -1;
1087

    
1088
            shorten_by = get_bits(&gb, 16);
1089
            if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1090
                s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1091
            else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
1092
                return -1;
1093

    
1094
            if (substr == m->max_decoded_substream)
1095
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1096
        }
1097

    
1098
        if (substream_parity_present[substr]) {
1099
            uint8_t parity, checksum;
1100

    
1101
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1102
                goto substream_length_mismatch;
1103

    
1104
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1105
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1106

    
1107
            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1108
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1109
            if ( get_bits(&gb, 8)           != checksum)
1110
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1111
        }
1112

    
1113
        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1114
            goto substream_length_mismatch;
1115

    
1116
next_substr:
1117
        if (!s->restart_seen)
1118
            av_log(m->avctx, AV_LOG_ERROR,
1119
                   "No restart header present in substream %d.\n", substr);
1120

    
1121
        buf += substream_data_len[substr];
1122
    }
1123

    
1124
    rematrix_channels(m, m->max_decoded_substream);
1125

    
1126
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1127
        return -1;
1128

    
1129
    return length;
1130

    
1131
substream_length_mismatch:
1132
    av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1133
    return -1;
1134

    
1135
error:
1136
    m->params_valid = 0;
1137
    return -1;
1138
}
1139

    
1140
AVCodec ff_mlp_decoder = {
1141
    "mlp",
1142
    AVMEDIA_TYPE_AUDIO,
1143
    CODEC_ID_MLP,
1144
    sizeof(MLPDecodeContext),
1145
    mlp_decode_init,
1146
    NULL,
1147
    NULL,
1148
    read_access_unit,
1149
    .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1150
};
1151

    
1152
#if CONFIG_TRUEHD_DECODER
1153
AVCodec ff_truehd_decoder = {
1154
    "truehd",
1155
    AVMEDIA_TYPE_AUDIO,
1156
    CODEC_ID_TRUEHD,
1157
    sizeof(MLPDecodeContext),
1158
    mlp_decode_init,
1159
    NULL,
1160
    NULL,
1161
    read_access_unit,
1162
    .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1163
};
1164
#endif /* CONFIG_TRUEHD_DECODER */