Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ 72415b2a

History | View | Annotate | Download (38.1 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 "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
    //! The left shift applied to random noise in 0x31ea substreams.
66
    uint8_t     noise_shift;
67
    //! The current seed value for the pseudorandom noise generator(s).
68
    uint32_t    noisegen_seed;
69

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

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

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

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

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

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

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

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

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

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

    
116
} SubStream;
117

    
118
typedef struct MLPDecodeContext {
119
    AVCodecContext *avctx;
120

    
121
    //! Current access unit being read has a major sync.
122
    int         is_major_sync_unit;
123

    
124
    //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
125
    uint8_t     params_valid;
126

    
127
    //! Number of substreams contained within this stream.
128
    uint8_t     num_substreams;
129

    
130
    //! Index of the last substream to decode - further substreams are skipped.
131
    uint8_t     max_decoded_substream;
132

    
133
    //! number of PCM samples contained in each frame
134
    int         access_unit_size;
135
    //! next power of two above the number of samples in each frame
136
    int         access_unit_size_pow2;
137

    
138
    SubStream   substream[MAX_SUBSTREAMS];
139

    
140
    ChannelParams channel_params[MAX_CHANNELS];
141

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

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

    
149
    DSPContext  dsp;
150
} MLPDecodeContext;
151

    
152
static VLC huff_vlc[3];
153

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

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

    
170
    ff_mlp_init_crc();
171
}
172

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

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

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

    
188
    return sign_huff_offset;
189
}
190

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

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

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

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

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

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

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

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

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

    
227
    return 0;
228
}
229

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

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

    
241
    return 0;
242
}
243

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

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

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

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

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

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

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

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

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

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

    
318
    m->avctx->bits_per_raw_sample = mh.group1_bits;
319
    if (mh.group1_bits > 16)
320
        m->avctx->sample_fmt = SAMPLE_FMT_S32;
321
    else
322
        m->avctx->sample_fmt = SAMPLE_FMT_S16;
323

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

    
328
    return 0;
329
}
330

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

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

    
348
    sync_word = get_bits(gbp, 13);
349

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

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

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

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

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

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

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

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

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

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

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

    
410
    skip_bits(gbp, 19);
411

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

    
423
    skip_bits(gbp, 16);
424

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

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

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

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

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

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

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

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

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

    
469
    return 0;
470
}
471

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

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

    
482
    // Filter is 0 for FIR, 1 for IIR.
483
    assert(filter < 2);
484

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

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

    
499
    if (order > 0) {
500
        int32_t *fcoeff = m->channel_params[channel].coeff[filter];
501
        int coeff_bits, coeff_shift;
502

    
503
        fp->shift = get_bits(gbp, 4);
504

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

    
520
        for (i = 0; i < order; i++)
521
            fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
522

    
523
        if (get_bits1(gbp)) {
524
            int state_bits, state_shift;
525

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

    
532
            state_bits  = get_bits(gbp, 4);
533
            state_shift = get_bits(gbp, 4);
534

    
535
            /* TODO: Check validity of state data. */
536

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

    
542
    return 0;
543
}
544

    
545
/** Read parameters for primitive matrices. */
546

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

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

    
560
    s->num_primitive_matrices = get_bits(gbp, 4);
561

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

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

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

    
587
        max_chan = s->max_matrix_channel;
588
        if (!s->noise_type)
589
            max_chan+=2;
590

    
591
        for (ch = 0; ch <= max_chan; ch++) {
592
            int coeff_val = 0;
593
            if (get_bits1(gbp))
594
                coeff_val = get_sbits(gbp, frac_bits + 2);
595

    
596
            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
597
        }
598

    
599
        if (s->noise_type)
600
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
601
        else
602
            s->matrix_noise_shift[mat] = 0;
603
    }
604

    
605
    return 0;
606
}
607

    
608
/** Read channel parameters. */
609

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

    
618
    if (s->param_presence_flags & PARAM_FIR)
619
        if (get_bits1(gbp))
620
            if (read_filter_params(m, gbp, ch, FIR) < 0)
621
                return -1;
622

    
623
    if (s->param_presence_flags & PARAM_IIR)
624
        if (get_bits1(gbp))
625
            if (read_filter_params(m, gbp, ch, IIR) < 0)
626
                return -1;
627

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

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

    
647
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
648
        if (get_bits1(gbp))
649
            cp->huff_offset = get_sbits(gbp, 15);
650

    
651
    cp->codebook  = get_bits(gbp, 2);
652
    cp->huff_lsbs = get_bits(gbp, 5);
653

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

    
659
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
660

    
661
    return 0;
662
}
663

    
664
/** Read decoding parameters that change more often than those in the restart
665
 *  header. */
666

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

    
673
    if (s->param_presence_flags & PARAM_PRESENCE)
674
        if (get_bits1(gbp))
675
            s->param_presence_flags = get_bits(gbp, 8);
676

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

    
687
    if (s->param_presence_flags & PARAM_MATRIX)
688
        if (get_bits1(gbp))
689
            if (read_matrix_params(m, substr, gbp) < 0)
690
                return -1;
691

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

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

    
702
                s->quant_step_size[ch] = get_bits(gbp, 4);
703

    
704
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
705
            }
706

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

    
712
    return 0;
713
}
714

    
715
#define MSB_MASK(bits)  (-1u << bits)
716

    
717
/** Generate PCM samples using the prediction filters and residual values
718
 *  read from the data stream, and update the filter state. */
719

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

    
733
    memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
734
    memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
735

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

    
741
    memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
742
    memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
743
}
744

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

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

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

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

    
765
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
766
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
767

    
768
    for (i = 0; i < s->blocksize; i++)
769
        if (read_huff_channels(m, gbp, substr, i) < 0)
770
            return -1;
771

    
772
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
773
        filter_channel(m, substr, ch);
774

    
775
    s->blockpos += s->blocksize;
776

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

    
783
    return 0;
784
}
785

    
786
/** Data table used for TrueHD noise generation function. */
787

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

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

    
814
/** Generate two channels of noise, used in the matrix when
815
 *  restart sync word == 0x31ea. */
816

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

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

    
829
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
830
    }
831

    
832
    s->noisegen_seed = seed;
833
}
834

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

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

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

    
849
    s->noisegen_seed = seed;
850
}
851

    
852

    
853
/** Apply the channel matrices in turn to reconstruct the original audio
854
 *  samples. */
855

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

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

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

    
878
        /* TODO: DSPContext? */
879

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

    
885
            for (src_ch = 0; src_ch <= maxchan; src_ch++)
886
                accum += (int64_t) samples[src_ch] * coeffs[src_ch];
887

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

    
894
            samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
895
        }
896
    }
897
}
898

    
899
/** Write the audio data into the output buffer. */
900

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

    
909
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
910
        return -1;
911

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

    
923
    *data_size = i * out_ch * (is32 ? 4 : 2);
924

    
925
    return 0;
926
}
927

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

    
937

    
938
/** Read an access unit from the stream.
939
 *  Returns < 0 on error, 0 if not enough data is present in the input stream
940
 *  otherwise returns the number of bytes consumed. */
941

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

    
957
    if (buf_size < 4)
958
        return 0;
959

    
960
    length = (AV_RB16(buf) & 0xfff) * 2;
961

    
962
    if (length < 4 || length > buf_size)
963
        return -1;
964

    
965
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
966

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

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

    
982
    substream_start = 0;
983

    
984
    for (substr = 0; substr < m->num_substreams; substr++) {
985
        int extraword_present, checkdata_present, end, nonrestart_substr;
986

    
987
        extraword_present = get_bits1(&gb);
988
        nonrestart_substr = get_bits1(&gb);
989
        checkdata_present = get_bits1(&gb);
990
        skip_bits1(&gb);
991

    
992
        end = get_bits(&gb, 12) * 2;
993

    
994
        substr_header_size += 2;
995

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

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

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

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

    
1025
        if (substr > m->max_decoded_substream)
1026
            continue;
1027

    
1028
        substream_parity_present[substr] = checkdata_present;
1029
        substream_data_len[substr] = end - substream_start;
1030
        substream_start = end;
1031
    }
1032

    
1033
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
1034
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1035

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

    
1041
    buf += header_size + substr_header_size;
1042

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

    
1047
        m->matrix_changed = 0;
1048
        memset(m->filter_changed, 0, sizeof(m->filter_changed));
1049

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

    
1060
                if (!s->restart_seen)
1061
                    goto next_substr;
1062
                if (read_decoding_params(m, &gb, substr) < 0)
1063
                    goto next_substr;
1064
            }
1065

    
1066
            if (!s->restart_seen)
1067
                goto next_substr;
1068

    
1069
            if (read_block_data(m, &gb, substr) < 0)
1070
                return -1;
1071

    
1072
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1073
                goto substream_length_mismatch;
1074

    
1075
        } while (!get_bits1(&gb));
1076

    
1077
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1078

    
1079
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1080
            int shorten_by;
1081

    
1082
            if (get_bits(&gb, 16) != 0xD234)
1083
                return -1;
1084

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

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

    
1095
        if (substream_parity_present[substr]) {
1096
            uint8_t parity, checksum;
1097

    
1098
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1099
                goto substream_length_mismatch;
1100

    
1101
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1102
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1103

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

    
1110
        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1111
            goto substream_length_mismatch;
1112

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

    
1118
        buf += substream_data_len[substr];
1119
    }
1120

    
1121
    rematrix_channels(m, m->max_decoded_substream);
1122

    
1123
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1124
        return -1;
1125

    
1126
    return length;
1127

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

    
1132
error:
1133
    m->params_valid = 0;
1134
    return -1;
1135
}
1136

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

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