Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ 0c5670a0

History | View | Annotate | Download (35.5 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 libavcodec/mlpdec.c
24
 * MLP decoder
25
 */
26

    
27
#include <stdint.h>
28

    
29
#include "avcodec.h"
30
#include "libavutil/intreadwrite.h"
31
#include "bitstream.h"
32
#include "libavutil/crc.h"
33
#include "parser.h"
34
#include "mlp_parser.h"
35
#include "mlp.h"
36

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

    
40

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

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

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

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

    
64
    //! The left shift applied to random noise in 0x31ea substreams.
65
    uint8_t     noise_shift;
66
    //! The current seed value for the pseudorandom noise generator(s).
67
    uint32_t    noisegen_seed;
68

    
69
    //! Set if the substream contains extra info to check the size of VLC blocks.
70
    uint8_t     data_check_present;
71

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

    
84
    //@{
85
    /** matrix data */
86

    
87
    //! Number of matrices to be applied.
88
    uint8_t     num_primitive_matrices;
89

    
90
    //! matrix output channel
91
    uint8_t     matrix_out_ch[MAX_MATRICES];
92

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

    
101
    //! Left shift to apply to Huffman-decoded residuals.
102
    uint8_t     quant_step_size[MAX_CHANNELS];
103

    
104
    //! number of PCM samples in current audio block
105
    uint16_t    blocksize;
106
    //! Number of PCM samples decoded so far in this frame.
107
    uint16_t    blockpos;
108

    
109
    //! Left shift to apply to decoded PCM values to get final 24-bit output.
110
    int8_t      output_shift[MAX_CHANNELS];
111

    
112
    //! Running XOR of all output samples.
113
    int32_t     lossless_check_data;
114

    
115
} SubStream;
116

    
117
typedef struct MLPDecodeContext {
118
    AVCodecContext *avctx;
119

    
120
    //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
121
    uint8_t     params_valid;
122

    
123
    //! Number of substreams contained within this stream.
124
    uint8_t     num_substreams;
125

    
126
    //! Index of the last substream to decode - further substreams are skipped.
127
    uint8_t     max_decoded_substream;
128

    
129
    //! number of PCM samples contained in each frame
130
    int         access_unit_size;
131
    //! next power of two above the number of samples in each frame
132
    int         access_unit_size_pow2;
133

    
134
    SubStream   substream[MAX_SUBSTREAMS];
135

    
136
    ChannelParams channel_params[MAX_CHANNELS];
137

    
138
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
139
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
140
    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS+2];
141
} MLPDecodeContext;
142

    
143
static VLC huff_vlc[3];
144

    
145
/** Initialize static data, constant between all invocations of the codec. */
146

    
147
static av_cold void init_static(void)
148
{
149
    INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
150
                &ff_mlp_huffman_tables[0][0][1], 2, 1,
151
                &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
152
    INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
153
                &ff_mlp_huffman_tables[1][0][1], 2, 1,
154
                &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
155
    INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
156
                &ff_mlp_huffman_tables[2][0][1], 2, 1,
157
                &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
158

    
159
    ff_mlp_init_crc();
160
}
161

    
162
static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
163
                                          unsigned int substr, unsigned int ch)
164
{
165
    ChannelParams *cp = &m->channel_params[ch];
166
    SubStream *s = &m->substream[substr];
167
    int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
168
    int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
169
    int32_t sign_huff_offset = cp->huff_offset;
170

    
171
    if (cp->codebook > 0)
172
        sign_huff_offset -= 7 << lsb_bits;
173

    
174
    if (sign_shift >= 0)
175
        sign_huff_offset -= 1 << sign_shift;
176

    
177
    return sign_huff_offset;
178
}
179

    
180
/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
181
 *  and plain LSBs. */
182

    
183
static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
184
                                     unsigned int substr, unsigned int pos)
185
{
186
    SubStream *s = &m->substream[substr];
187
    unsigned int mat, channel;
188

    
189
    for (mat = 0; mat < s->num_primitive_matrices; mat++)
190
        if (s->lsb_bypass[mat])
191
            m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
192

    
193
    for (channel = s->min_channel; channel <= s->max_channel; channel++) {
194
        ChannelParams *cp = &m->channel_params[channel];
195
        int codebook = cp->codebook;
196
        int quant_step_size = s->quant_step_size[channel];
197
        int lsb_bits = cp->huff_lsbs - quant_step_size;
198
        int result = 0;
199

    
200
        if (codebook > 0)
201
            result = get_vlc2(gbp, huff_vlc[codebook-1].table,
202
                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
203

    
204
        if (result < 0)
205
            return -1;
206

    
207
        if (lsb_bits > 0)
208
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
209

    
210
        result  += cp->sign_huff_offset;
211
        result <<= quant_step_size;
212

    
213
        m->sample_buffer[pos + s->blockpos][channel] = result;
214
    }
215

    
216
    return 0;
217
}
218

    
219
static av_cold int mlp_decode_init(AVCodecContext *avctx)
220
{
221
    MLPDecodeContext *m = avctx->priv_data;
222
    int substr;
223

    
224
    init_static();
225
    m->avctx = avctx;
226
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
227
        m->substream[substr].lossless_check_data = 0xffffffff;
228

    
229
    return 0;
230
}
231

    
232
/** Read a major sync info header - contains high level information about
233
 *  the stream - sample rate, channel arrangement etc. Most of this
234
 *  information is not actually necessary for decoding, only for playback.
235
 */
236

    
237
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
238
{
239
    MLPHeaderInfo mh;
240
    int substr;
241

    
242
    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
243
        return -1;
244

    
245
    if (mh.group1_bits == 0) {
246
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
247
        return -1;
248
    }
249
    if (mh.group2_bits > mh.group1_bits) {
250
        av_log(m->avctx, AV_LOG_ERROR,
251
               "Channel group 2 cannot have more bits per sample than group 1.\n");
252
        return -1;
253
    }
254

    
255
    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
256
        av_log(m->avctx, AV_LOG_ERROR,
257
               "Channel groups with differing sample rates are not currently supported.\n");
258
        return -1;
259
    }
260

    
261
    if (mh.group1_samplerate == 0) {
262
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
263
        return -1;
264
    }
265
    if (mh.group1_samplerate > MAX_SAMPLERATE) {
266
        av_log(m->avctx, AV_LOG_ERROR,
267
               "Sampling rate %d is greater than the supported maximum (%d).\n",
268
               mh.group1_samplerate, MAX_SAMPLERATE);
269
        return -1;
270
    }
271
    if (mh.access_unit_size > MAX_BLOCKSIZE) {
272
        av_log(m->avctx, AV_LOG_ERROR,
273
               "Block size %d is greater than the supported maximum (%d).\n",
274
               mh.access_unit_size, MAX_BLOCKSIZE);
275
        return -1;
276
    }
277
    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
278
        av_log(m->avctx, AV_LOG_ERROR,
279
               "Block size pow2 %d is greater than the supported maximum (%d).\n",
280
               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
281
        return -1;
282
    }
283

    
284
    if (mh.num_substreams == 0)
285
        return -1;
286
    if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
287
        av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
288
        return -1;
289
    }
290
    if (mh.num_substreams > MAX_SUBSTREAMS) {
291
        av_log(m->avctx, AV_LOG_ERROR,
292
               "Number of substreams %d is larger than the maximum supported "
293
               "by the decoder. %s\n", mh.num_substreams, sample_message);
294
        return -1;
295
    }
296

    
297
    m->access_unit_size      = mh.access_unit_size;
298
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;
299

    
300
    m->num_substreams        = mh.num_substreams;
301
    m->max_decoded_substream = m->num_substreams - 1;
302

    
303
    m->avctx->sample_rate    = mh.group1_samplerate;
304
    m->avctx->frame_size     = mh.access_unit_size;
305

    
306
    m->avctx->bits_per_raw_sample = mh.group1_bits;
307
    if (mh.group1_bits > 16)
308
        m->avctx->sample_fmt = SAMPLE_FMT_S32;
309
    else
310
        m->avctx->sample_fmt = SAMPLE_FMT_S16;
311

    
312
    m->params_valid = 1;
313
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
314
        m->substream[substr].restart_seen = 0;
315

    
316
    return 0;
317
}
318

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

    
323
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
324
                               const uint8_t *buf, unsigned int substr)
325
{
326
    SubStream *s = &m->substream[substr];
327
    unsigned int ch;
328
    int sync_word, tmp;
329
    uint8_t checksum;
330
    uint8_t lossless_check;
331
    int start_count = get_bits_count(gbp);
332

    
333
    sync_word = get_bits(gbp, 13);
334

    
335
    if (sync_word != 0x31ea >> 1) {
336
        av_log(m->avctx, AV_LOG_ERROR,
337
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
338
        return -1;
339
    }
340
    s->noise_type = get_bits1(gbp);
341

    
342
    skip_bits(gbp, 16); /* Output timestamp */
343

    
344
    s->min_channel        = get_bits(gbp, 4);
345
    s->max_channel        = get_bits(gbp, 4);
346
    s->max_matrix_channel = get_bits(gbp, 4);
347

    
348
    if (s->min_channel > s->max_channel) {
349
        av_log(m->avctx, AV_LOG_ERROR,
350
               "Substream min channel cannot be greater than max channel.\n");
351
        return -1;
352
    }
353

    
354
    if (m->avctx->request_channels > 0
355
        && s->max_channel + 1 >= m->avctx->request_channels
356
        && substr < m->max_decoded_substream) {
357
        av_log(m->avctx, AV_LOG_INFO,
358
               "Extracting %d channel downmix from substream %d. "
359
               "Further substreams will be skipped.\n",
360
               s->max_channel + 1, substr);
361
        m->max_decoded_substream = substr;
362
    }
363

    
364
    s->noise_shift   = get_bits(gbp,  4);
365
    s->noisegen_seed = get_bits(gbp, 23);
366

    
367
    skip_bits(gbp, 19);
368

    
369
    s->data_check_present = get_bits1(gbp);
370
    lossless_check = get_bits(gbp, 8);
371
    if (substr == m->max_decoded_substream
372
        && s->lossless_check_data != 0xffffffff) {
373
        tmp = xor_32_to_8(s->lossless_check_data);
374
        if (tmp != lossless_check)
375
            av_log(m->avctx, AV_LOG_WARNING,
376
                   "Lossless check failed - expected %02x, calculated %02x.\n",
377
                   lossless_check, tmp);
378
    }
379

    
380
    skip_bits(gbp, 16);
381

    
382
    memset(s->ch_assign, 0, sizeof(s->ch_assign));
383

    
384
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
385
        int ch_assign = get_bits(gbp, 6);
386
        if (ch_assign > s->max_matrix_channel) {
387
            av_log(m->avctx, AV_LOG_ERROR,
388
                   "Assignment of matrix channel %d to invalid output channel %d. %s\n",
389
                   ch, ch_assign, sample_message);
390
            return -1;
391
        }
392
        s->ch_assign[ch_assign] = ch;
393
    }
394

    
395
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
396

    
397
    if (checksum != get_bits(gbp, 8))
398
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
399

    
400
    /* Set default decoding parameters. */
401
    s->param_presence_flags   = 0xff;
402
    s->num_primitive_matrices = 0;
403
    s->blocksize              = 8;
404
    s->lossless_check_data    = 0;
405

    
406
    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
407
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
408

    
409
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
410
        ChannelParams *cp = &m->channel_params[ch];
411
        cp->filter_params[FIR].order = 0;
412
        cp->filter_params[IIR].order = 0;
413
        cp->filter_params[FIR].shift = 0;
414
        cp->filter_params[IIR].shift = 0;
415

    
416
        /* Default audio coding is 24-bit raw PCM. */
417
        cp->huff_offset      = 0;
418
        cp->sign_huff_offset = (-1) << 23;
419
        cp->codebook         = 0;
420
        cp->huff_lsbs        = 24;
421
    }
422

    
423
    if (substr == m->max_decoded_substream) {
424
        m->avctx->channels = s->max_matrix_channel + 1;
425
    }
426

    
427
    return 0;
428
}
429

    
430
/** Read parameters for one of the prediction filters. */
431

    
432
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
433
                              unsigned int channel, unsigned int filter)
434
{
435
    FilterParams *fp = &m->channel_params[channel].filter_params[filter];
436
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
437
    const char fchar = filter ? 'I' : 'F';
438
    int i, order;
439

    
440
    // Filter is 0 for FIR, 1 for IIR.
441
    assert(filter < 2);
442

    
443
    order = get_bits(gbp, 4);
444
    if (order > max_order) {
445
        av_log(m->avctx, AV_LOG_ERROR,
446
               "%cIR filter order %d is greater than maximum %d.\n",
447
               fchar, order, max_order);
448
        return -1;
449
    }
450
    fp->order = order;
451

    
452
    if (order > 0) {
453
        int coeff_bits, coeff_shift;
454

    
455
        fp->shift = get_bits(gbp, 4);
456

    
457
        coeff_bits  = get_bits(gbp, 5);
458
        coeff_shift = get_bits(gbp, 3);
459
        if (coeff_bits < 1 || coeff_bits > 16) {
460
            av_log(m->avctx, AV_LOG_ERROR,
461
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
462
                   fchar);
463
            return -1;
464
        }
465
        if (coeff_bits + coeff_shift > 16) {
466
            av_log(m->avctx, AV_LOG_ERROR,
467
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
468
                   fchar);
469
            return -1;
470
        }
471

    
472
        for (i = 0; i < order; i++)
473
            fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
474

    
475
        if (get_bits1(gbp)) {
476
            int state_bits, state_shift;
477

    
478
            if (filter == FIR) {
479
                av_log(m->avctx, AV_LOG_ERROR,
480
                       "FIR filter has state data specified.\n");
481
                return -1;
482
            }
483

    
484
            state_bits  = get_bits(gbp, 4);
485
            state_shift = get_bits(gbp, 4);
486

    
487
            /* TODO: Check validity of state data. */
488

    
489
            for (i = 0; i < order; i++)
490
                fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
491
        }
492
    }
493

    
494
    return 0;
495
}
496

    
497
/** Read parameters for primitive matrices. */
498

    
499
static int read_matrix_params(MLPDecodeContext *m, SubStream *s, GetBitContext *gbp)
500
{
501
    unsigned int mat, ch;
502

    
503
    s->num_primitive_matrices = get_bits(gbp, 4);
504

    
505
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
506
        int frac_bits, max_chan;
507
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
508
        frac_bits             = get_bits(gbp, 4);
509
        s->lsb_bypass   [mat] = get_bits1(gbp);
510

    
511
        if (s->matrix_out_ch[mat] > s->max_channel) {
512
            av_log(m->avctx, AV_LOG_ERROR,
513
                    "Invalid channel %d specified as output from matrix.\n",
514
                    s->matrix_out_ch[mat]);
515
            return -1;
516
        }
517
        if (frac_bits > 14) {
518
            av_log(m->avctx, AV_LOG_ERROR,
519
                    "Too many fractional bits specified.\n");
520
            return -1;
521
        }
522

    
523
        max_chan = s->max_matrix_channel;
524
        if (!s->noise_type)
525
            max_chan+=2;
526

    
527
        for (ch = 0; ch <= max_chan; ch++) {
528
            int coeff_val = 0;
529
            if (get_bits1(gbp))
530
                coeff_val = get_sbits(gbp, frac_bits + 2);
531

    
532
            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
533
        }
534

    
535
        if (s->noise_type)
536
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
537
        else
538
            s->matrix_noise_shift[mat] = 0;
539
    }
540

    
541
    return 0;
542
}
543

    
544
/** Read channel parameters. */
545

    
546
static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
547
                               GetBitContext *gbp, unsigned int ch)
548
{
549
    ChannelParams *cp = &m->channel_params[ch];
550
    FilterParams *fir = &cp->filter_params[FIR];
551
    FilterParams *iir = &cp->filter_params[IIR];
552
    SubStream *s = &m->substream[substr];
553

    
554
    if (s->param_presence_flags & PARAM_FIR)
555
        if (get_bits1(gbp))
556
            if (read_filter_params(m, gbp, ch, FIR) < 0)
557
                return -1;
558

    
559
    if (s->param_presence_flags & PARAM_IIR)
560
        if (get_bits1(gbp))
561
            if (read_filter_params(m, gbp, ch, IIR) < 0)
562
                return -1;
563

    
564
    if (fir->order && iir->order &&
565
        fir->shift != iir->shift) {
566
        av_log(m->avctx, AV_LOG_ERROR,
567
                "FIR and IIR filters must use the same precision.\n");
568
        return -1;
569
    }
570
    /* The FIR and IIR filters must have the same precision.
571
        * To simplify the filtering code, only the precision of the
572
        * FIR filter is considered. If only the IIR filter is employed,
573
        * the FIR filter precision is set to that of the IIR filter, so
574
        * that the filtering code can use it. */
575
    if (!fir->order && iir->order)
576
        fir->shift = iir->shift;
577

    
578
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
579
        if (get_bits1(gbp))
580
            cp->huff_offset = get_sbits(gbp, 15);
581

    
582
    cp->codebook  = get_bits(gbp, 2);
583
    cp->huff_lsbs = get_bits(gbp, 5);
584

    
585
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
586

    
587
    /* TODO: validate */
588

    
589
    return 0;
590
}
591

    
592
/** Read decoding parameters that change more often than those in the restart
593
 *  header. */
594

    
595
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
596
                                unsigned int substr)
597
{
598
    SubStream *s = &m->substream[substr];
599
    unsigned int ch;
600

    
601
    if (s->param_presence_flags & PARAM_PRESENCE)
602
    if (get_bits1(gbp))
603
        s->param_presence_flags = get_bits(gbp, 8);
604

    
605
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
606
        if (get_bits1(gbp)) {
607
            s->blocksize = get_bits(gbp, 9);
608
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
609
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
610
                s->blocksize = 0;
611
                return -1;
612
            }
613
        }
614

    
615
    if (s->param_presence_flags & PARAM_MATRIX)
616
        if (get_bits1(gbp)) {
617
            if (read_matrix_params(m, s, gbp) < 0)
618
                return -1;
619
        }
620

    
621
    if (s->param_presence_flags & PARAM_OUTSHIFT)
622
        if (get_bits1(gbp))
623
            for (ch = 0; ch <= s->max_matrix_channel; ch++) {
624
                s->output_shift[ch] = get_sbits(gbp, 4);
625
            }
626

    
627
    if (s->param_presence_flags & PARAM_QUANTSTEP)
628
        if (get_bits1(gbp))
629
            for (ch = 0; ch <= s->max_channel; ch++) {
630
                ChannelParams *cp = &m->channel_params[ch];
631

    
632
                s->quant_step_size[ch] = get_bits(gbp, 4);
633

    
634
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
635
            }
636

    
637
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
638
        if (get_bits1(gbp)) {
639
            if (read_channel_params(m, substr, gbp, ch) < 0)
640
                return -1;
641
        }
642

    
643
    return 0;
644
}
645

    
646
#define MSB_MASK(bits)  (-1u << bits)
647

    
648
/** Generate PCM samples using the prediction filters and residual values
649
 *  read from the data stream, and update the filter state. */
650

    
651
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
652
                           unsigned int channel)
653
{
654
    SubStream *s = &m->substream[substr];
655
    int32_t filter_state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
656
    FilterParams *fp[NUM_FILTERS] = { &m->channel_params[channel].filter_params[FIR],
657
                                      &m->channel_params[channel].filter_params[IIR], };
658
    unsigned int filter_shift = fp[FIR]->shift;
659
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
660
    int index = MAX_BLOCKSIZE;
661
    int j, i;
662

    
663
    for (j = 0; j < NUM_FILTERS; j++) {
664
        memcpy(&filter_state_buffer[j][MAX_BLOCKSIZE], &fp[j]->state[0],
665
               MAX_FIR_ORDER * sizeof(int32_t));
666
    }
667

    
668
    for (i = 0; i < s->blocksize; i++) {
669
        int32_t residual = m->sample_buffer[i + s->blockpos][channel];
670
        unsigned int order;
671
        int64_t accum = 0;
672
        int32_t result;
673

    
674
        /* TODO: Move this code to DSPContext? */
675

    
676
        for (j = 0; j < NUM_FILTERS; j++)
677
            for (order = 0; order < fp[j]->order; order++)
678
                accum += (int64_t)filter_state_buffer[j][index + order] *
679
                                  fp[j]->coeff[order];
680

    
681
        accum  = accum >> filter_shift;
682
        result = (accum + residual) & mask;
683

    
684
        --index;
685

    
686
        filter_state_buffer[FIR][index] = result;
687
        filter_state_buffer[IIR][index] = result - accum;
688

    
689
        m->sample_buffer[i + s->blockpos][channel] = result;
690
    }
691

    
692
    for (j = 0; j < NUM_FILTERS; j++) {
693
        memcpy(&fp[j]->state[0], &filter_state_buffer[j][index],
694
               MAX_FIR_ORDER * sizeof(int32_t));
695
    }
696
}
697

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

    
700
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
701
                           unsigned int substr)
702
{
703
    SubStream *s = &m->substream[substr];
704
    unsigned int i, ch, expected_stream_pos = 0;
705

    
706
    if (s->data_check_present) {
707
        expected_stream_pos  = get_bits_count(gbp);
708
        expected_stream_pos += get_bits(gbp, 16);
709
        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
710
               "we have not tested yet. %s\n", sample_message);
711
    }
712

    
713
    if (s->blockpos + s->blocksize > m->access_unit_size) {
714
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
715
        return -1;
716
    }
717

    
718
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
719
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
720

    
721
    for (i = 0; i < s->blocksize; i++) {
722
        if (read_huff_channels(m, gbp, substr, i) < 0)
723
            return -1;
724
    }
725

    
726
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
727
        filter_channel(m, substr, ch);
728
    }
729

    
730
    s->blockpos += s->blocksize;
731

    
732
    if (s->data_check_present) {
733
        if (get_bits_count(gbp) != expected_stream_pos)
734
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
735
        skip_bits(gbp, 8);
736
    }
737

    
738
    return 0;
739
}
740

    
741
/** Data table used for TrueHD noise generation function. */
742

    
743
static const int8_t noise_table[256] = {
744
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
745
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
746
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
747
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
748
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
749
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
750
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
751
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
752
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
753
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
754
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
755
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
756
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
757
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
758
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
759
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
760
};
761

    
762
/** Noise generation functions.
763
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
764
 *  sequence generators, used to generate noise data which is used when the
765
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
766
 *  to compression, or just obfuscate the decoder. Are they for some kind of
767
 *  dithering? */
768

    
769
/** Generate two channels of noise, used in the matrix when
770
 *  restart sync word == 0x31ea. */
771

    
772
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
773
{
774
    SubStream *s = &m->substream[substr];
775
    unsigned int i;
776
    uint32_t seed = s->noisegen_seed;
777
    unsigned int maxchan = s->max_matrix_channel;
778

    
779
    for (i = 0; i < s->blockpos; i++) {
780
        uint16_t seed_shr7 = seed >> 7;
781
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
782
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
783

    
784
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
785
    }
786

    
787
    s->noisegen_seed = seed;
788
}
789

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

    
792
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
793
{
794
    SubStream *s = &m->substream[substr];
795
    unsigned int i;
796
    uint32_t seed = s->noisegen_seed;
797

    
798
    for (i = 0; i < m->access_unit_size_pow2; i++) {
799
        uint8_t seed_shr15 = seed >> 15;
800
        m->noise_buffer[i] = noise_table[seed_shr15];
801
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
802
    }
803

    
804
    s->noisegen_seed = seed;
805
}
806

    
807

    
808
/** Apply the channel matrices in turn to reconstruct the original audio
809
 *  samples. */
810

    
811
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
812
{
813
    SubStream *s = &m->substream[substr];
814
    unsigned int mat, src_ch, i;
815
    unsigned int maxchan;
816

    
817
    maxchan = s->max_matrix_channel;
818
    if (!s->noise_type) {
819
        generate_2_noise_channels(m, substr);
820
        maxchan += 2;
821
    } else {
822
        fill_noise_buffer(m, substr);
823
    }
824

    
825
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
826
        int matrix_noise_shift = s->matrix_noise_shift[mat];
827
        unsigned int dest_ch = s->matrix_out_ch[mat];
828
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
829

    
830
        /* TODO: DSPContext? */
831

    
832
        for (i = 0; i < s->blockpos; i++) {
833
            int64_t accum = 0;
834
            for (src_ch = 0; src_ch <= maxchan; src_ch++) {
835
                accum += (int64_t)m->sample_buffer[i][src_ch]
836
                                  * s->matrix_coeff[mat][src_ch];
837
            }
838
            if (matrix_noise_shift) {
839
                uint32_t index = s->num_primitive_matrices - mat;
840
                index = (i * (index * 2 + 1) + index) & (m->access_unit_size_pow2 - 1);
841
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
842
            }
843
            m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
844
                                             + m->bypassed_lsbs[i][mat];
845
        }
846
    }
847
}
848

    
849
/** Write the audio data into the output buffer. */
850

    
851
static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
852
                                uint8_t *data, unsigned int *data_size, int is32)
853
{
854
    SubStream *s = &m->substream[substr];
855
    unsigned int i, out_ch = 0;
856
    int32_t *data_32 = (int32_t*) data;
857
    int16_t *data_16 = (int16_t*) data;
858

    
859
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
860
        return -1;
861

    
862
    for (i = 0; i < s->blockpos; i++) {
863
        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
864
            int mat_ch = s->ch_assign[out_ch];
865
            int32_t sample = m->sample_buffer[i][mat_ch]
866
                          << s->output_shift[mat_ch];
867
            s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
868
            if (is32) *data_32++ = sample << 8;
869
            else      *data_16++ = sample >> 8;
870
        }
871
    }
872

    
873
    *data_size = i * out_ch * (is32 ? 4 : 2);
874

    
875
    return 0;
876
}
877

    
878
static int output_data(MLPDecodeContext *m, unsigned int substr,
879
                       uint8_t *data, unsigned int *data_size)
880
{
881
    if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
882
        return output_data_internal(m, substr, data, data_size, 1);
883
    else
884
        return output_data_internal(m, substr, data, data_size, 0);
885
}
886

    
887

    
888
/** Read an access unit from the stream.
889
 *  Returns < 0 on error, 0 if not enough data is present in the input stream
890
 *  otherwise returns the number of bytes consumed. */
891

    
892
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
893
                            const uint8_t *buf, int buf_size)
894
{
895
    MLPDecodeContext *m = avctx->priv_data;
896
    GetBitContext gb;
897
    unsigned int length, substr;
898
    unsigned int substream_start;
899
    unsigned int header_size = 4;
900
    unsigned int substr_header_size = 0;
901
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
902
    uint16_t substream_data_len[MAX_SUBSTREAMS];
903
    uint8_t parity_bits;
904

    
905
    if (buf_size < 4)
906
        return 0;
907

    
908
    length = (AV_RB16(buf) & 0xfff) * 2;
909

    
910
    if (length > buf_size)
911
        return -1;
912

    
913
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
914

    
915
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
916
        if (read_major_sync(m, &gb) < 0)
917
            goto error;
918
        header_size += 28;
919
    }
920

    
921
    if (!m->params_valid) {
922
        av_log(m->avctx, AV_LOG_WARNING,
923
               "Stream parameters not seen; skipping frame.\n");
924
        *data_size = 0;
925
        return length;
926
    }
927

    
928
    substream_start = 0;
929

    
930
    for (substr = 0; substr < m->num_substreams; substr++) {
931
        int extraword_present, checkdata_present, end;
932

    
933
        extraword_present = get_bits1(&gb);
934
        skip_bits1(&gb);
935
        checkdata_present = get_bits1(&gb);
936
        skip_bits1(&gb);
937

    
938
        end = get_bits(&gb, 12) * 2;
939

    
940
        substr_header_size += 2;
941

    
942
        if (extraword_present) {
943
            skip_bits(&gb, 16);
944
            substr_header_size += 2;
945
        }
946

    
947
        if (end + header_size + substr_header_size > length) {
948
            av_log(m->avctx, AV_LOG_ERROR,
949
                   "Indicated length of substream %d data goes off end of "
950
                   "packet.\n", substr);
951
            end = length - header_size - substr_header_size;
952
        }
953

    
954
        if (end < substream_start) {
955
            av_log(avctx, AV_LOG_ERROR,
956
                   "Indicated end offset of substream %d data "
957
                   "is smaller than calculated start offset.\n",
958
                   substr);
959
            goto error;
960
        }
961

    
962
        if (substr > m->max_decoded_substream)
963
            continue;
964

    
965
        substream_parity_present[substr] = checkdata_present;
966
        substream_data_len[substr] = end - substream_start;
967
        substream_start = end;
968
    }
969

    
970
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
971
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
972

    
973
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
974
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
975
        goto error;
976
    }
977

    
978
    buf += header_size + substr_header_size;
979

    
980
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
981
        SubStream *s = &m->substream[substr];
982
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
983

    
984
        s->blockpos = 0;
985
        do {
986
            if (get_bits1(&gb)) {
987
                if (get_bits1(&gb)) {
988
                    /* A restart header should be present. */
989
                    if (read_restart_header(m, &gb, buf, substr) < 0)
990
                        goto next_substr;
991
                    s->restart_seen = 1;
992
                }
993

    
994
                if (!s->restart_seen) {
995
                    av_log(m->avctx, AV_LOG_ERROR,
996
                           "No restart header present in substream %d.\n",
997
                           substr);
998
                    goto next_substr;
999
                }
1000

    
1001
                if (read_decoding_params(m, &gb, substr) < 0)
1002
                    goto next_substr;
1003
            }
1004

    
1005
            if (!s->restart_seen) {
1006
                av_log(m->avctx, AV_LOG_ERROR,
1007
                       "No restart header present in substream %d.\n",
1008
                       substr);
1009
                goto next_substr;
1010
            }
1011

    
1012
            if (read_block_data(m, &gb, substr) < 0)
1013
                return -1;
1014

    
1015
        } while ((get_bits_count(&gb) < substream_data_len[substr] * 8)
1016
                 && get_bits1(&gb) == 0);
1017

    
1018
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1019
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32 &&
1020
            (show_bits_long(&gb, 32) == END_OF_STREAM ||
1021
             show_bits_long(&gb, 20) == 0xd234e)) {
1022
            skip_bits(&gb, 18);
1023
            if (substr == m->max_decoded_substream)
1024
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1025

    
1026
            if (get_bits1(&gb)) {
1027
                int shorten_by = get_bits(&gb, 13);
1028
                shorten_by = FFMIN(shorten_by, s->blockpos);
1029
                s->blockpos -= shorten_by;
1030
            } else
1031
                skip_bits(&gb, 13);
1032
        }
1033
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 16 &&
1034
            substream_parity_present[substr]) {
1035
            uint8_t parity, checksum;
1036

    
1037
            parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1038
            if ((parity ^ get_bits(&gb, 8)) != 0xa9)
1039
                av_log(m->avctx, AV_LOG_ERROR,
1040
                       "Substream %d parity check failed.\n", substr);
1041

    
1042
            checksum = ff_mlp_checksum8(buf, substream_data_len[substr] - 2);
1043
            if (checksum != get_bits(&gb, 8))
1044
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n",
1045
                       substr);
1046
        }
1047
        if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
1048
            av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n",
1049
                   substr);
1050
            return -1;
1051
        }
1052

    
1053
next_substr:
1054
        buf += substream_data_len[substr];
1055
    }
1056

    
1057
    rematrix_channels(m, m->max_decoded_substream);
1058

    
1059
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1060
        return -1;
1061

    
1062
    return length;
1063

    
1064
error:
1065
    m->params_valid = 0;
1066
    return -1;
1067
}
1068

    
1069
#if CONFIG_MLP_DECODER
1070
AVCodec mlp_decoder = {
1071
    "mlp",
1072
    CODEC_TYPE_AUDIO,
1073
    CODEC_ID_MLP,
1074
    sizeof(MLPDecodeContext),
1075
    mlp_decode_init,
1076
    NULL,
1077
    NULL,
1078
    read_access_unit,
1079
    .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1080
};
1081
#endif /* CONFIG_MLP_DECODER */
1082

    
1083
#if CONFIG_TRUEHD_DECODER
1084
AVCodec truehd_decoder = {
1085
    "truehd",
1086
    CODEC_TYPE_AUDIO,
1087
    CODEC_ID_TRUEHD,
1088
    sizeof(MLPDecodeContext),
1089
    mlp_decode_init,
1090
    NULL,
1091
    NULL,
1092
    read_access_unit,
1093
    .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1094
};
1095
#endif /* CONFIG_TRUEHD_DECODER */