Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ 868170c4

History | View | Annotate | Download (37.4 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 "get_bits.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
    //! Current access unit being read has a major sync.
121
    int         is_major_sync_unit;
122

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

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

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

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

    
137
    SubStream   substream[MAX_SUBSTREAMS];
138

    
139
    ChannelParams channel_params[MAX_CHANNELS];
140

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

    
144
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
145
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
146
    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS+2];
147
} MLPDecodeContext;
148

    
149
static VLC huff_vlc[3];
150

    
151
/** Initialize static data, constant between all invocations of the codec. */
152

    
153
static av_cold void init_static(void)
154
{
155
    INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
156
                &ff_mlp_huffman_tables[0][0][1], 2, 1,
157
                &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
158
    INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
159
                &ff_mlp_huffman_tables[1][0][1], 2, 1,
160
                &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
161
    INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
162
                &ff_mlp_huffman_tables[2][0][1], 2, 1,
163
                &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
164

    
165
    ff_mlp_init_crc();
166
}
167

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

    
177
    if (cp->codebook > 0)
178
        sign_huff_offset -= 7 << lsb_bits;
179

    
180
    if (sign_shift >= 0)
181
        sign_huff_offset -= 1 << sign_shift;
182

    
183
    return sign_huff_offset;
184
}
185

    
186
/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
187
 *  and plain LSBs. */
188

    
189
static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
190
                                     unsigned int substr, unsigned int pos)
191
{
192
    SubStream *s = &m->substream[substr];
193
    unsigned int mat, channel;
194

    
195
    for (mat = 0; mat < s->num_primitive_matrices; mat++)
196
        if (s->lsb_bypass[mat])
197
            m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
198

    
199
    for (channel = s->min_channel; channel <= s->max_channel; channel++) {
200
        ChannelParams *cp = &m->channel_params[channel];
201
        int codebook = cp->codebook;
202
        int quant_step_size = s->quant_step_size[channel];
203
        int lsb_bits = cp->huff_lsbs - quant_step_size;
204
        int result = 0;
205

    
206
        if (codebook > 0)
207
            result = get_vlc2(gbp, huff_vlc[codebook-1].table,
208
                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
209

    
210
        if (result < 0)
211
            return -1;
212

    
213
        if (lsb_bits > 0)
214
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
215

    
216
        result  += cp->sign_huff_offset;
217
        result <<= quant_step_size;
218

    
219
        m->sample_buffer[pos + s->blockpos][channel] = result;
220
    }
221

    
222
    return 0;
223
}
224

    
225
static av_cold int mlp_decode_init(AVCodecContext *avctx)
226
{
227
    MLPDecodeContext *m = avctx->priv_data;
228
    int substr;
229

    
230
    init_static();
231
    m->avctx = avctx;
232
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
233
        m->substream[substr].lossless_check_data = 0xffffffff;
234

    
235
    return 0;
236
}
237

    
238
/** Read a major sync info header - contains high level information about
239
 *  the stream - sample rate, channel arrangement etc. Most of this
240
 *  information is not actually necessary for decoding, only for playback.
241
 */
242

    
243
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
244
{
245
    MLPHeaderInfo mh;
246
    int substr;
247

    
248
    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
249
        return -1;
250

    
251
    if (mh.group1_bits == 0) {
252
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
253
        return -1;
254
    }
255
    if (mh.group2_bits > mh.group1_bits) {
256
        av_log(m->avctx, AV_LOG_ERROR,
257
               "Channel group 2 cannot have more bits per sample than group 1.\n");
258
        return -1;
259
    }
260

    
261
    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
262
        av_log(m->avctx, AV_LOG_ERROR,
263
               "Channel groups with differing sample rates are not currently supported.\n");
264
        return -1;
265
    }
266

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

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

    
303
    m->access_unit_size      = mh.access_unit_size;
304
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;
305

    
306
    m->num_substreams        = mh.num_substreams;
307
    m->max_decoded_substream = m->num_substreams - 1;
308

    
309
    m->avctx->sample_rate    = mh.group1_samplerate;
310
    m->avctx->frame_size     = mh.access_unit_size;
311

    
312
    m->avctx->bits_per_raw_sample = mh.group1_bits;
313
    if (mh.group1_bits > 16)
314
        m->avctx->sample_fmt = SAMPLE_FMT_S32;
315
    else
316
        m->avctx->sample_fmt = SAMPLE_FMT_S16;
317

    
318
    m->params_valid = 1;
319
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
320
        m->substream[substr].restart_seen = 0;
321

    
322
    return 0;
323
}
324

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

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

    
342
    sync_word = get_bits(gbp, 13);
343
    s->noise_type = get_bits1(gbp);
344

    
345
    if ((m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) ||
346
        sync_word != 0x31ea >> 1) {
347
        av_log(m->avctx, AV_LOG_ERROR,
348
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
349
        return -1;
350
    }
351

    
352
    skip_bits(gbp, 16); /* Output timestamp */
353

    
354
    s->min_channel        = get_bits(gbp, 4);
355
    s->max_channel        = get_bits(gbp, 4);
356
    s->max_matrix_channel = get_bits(gbp, 4);
357

    
358
    if (s->max_matrix_channel > max_matrix_channel) {
359
        av_log(m->avctx, AV_LOG_ERROR,
360
               "Max matrix channel cannot be greater than %d.\n",
361
               max_matrix_channel);
362
        return -1;
363
    }
364

    
365
    if (s->max_channel != s->max_matrix_channel) {
366
        av_log(m->avctx, AV_LOG_ERROR,
367
               "Max channel must be equal max matrix channel.\n");
368
        return -1;
369
    }
370

    
371
    if (s->min_channel > s->max_channel) {
372
        av_log(m->avctx, AV_LOG_ERROR,
373
               "Substream min channel cannot be greater than max channel.\n");
374
        return -1;
375
    }
376

    
377
    if (m->avctx->request_channels > 0
378
        && s->max_channel + 1 >= m->avctx->request_channels
379
        && substr < m->max_decoded_substream) {
380
        av_log(m->avctx, AV_LOG_INFO,
381
               "Extracting %d channel downmix from substream %d. "
382
               "Further substreams will be skipped.\n",
383
               s->max_channel + 1, substr);
384
        m->max_decoded_substream = substr;
385
    }
386

    
387
    s->noise_shift   = get_bits(gbp,  4);
388
    s->noisegen_seed = get_bits(gbp, 23);
389

    
390
    skip_bits(gbp, 19);
391

    
392
    s->data_check_present = get_bits1(gbp);
393
    lossless_check = get_bits(gbp, 8);
394
    if (substr == m->max_decoded_substream
395
        && s->lossless_check_data != 0xffffffff) {
396
        tmp = xor_32_to_8(s->lossless_check_data);
397
        if (tmp != lossless_check)
398
            av_log(m->avctx, AV_LOG_WARNING,
399
                   "Lossless check failed - expected %02x, calculated %02x.\n",
400
                   lossless_check, tmp);
401
    }
402

    
403
    skip_bits(gbp, 16);
404

    
405
    memset(s->ch_assign, 0, sizeof(s->ch_assign));
406

    
407
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
408
        int ch_assign = get_bits(gbp, 6);
409
        if (ch_assign > s->max_matrix_channel) {
410
            av_log(m->avctx, AV_LOG_ERROR,
411
                   "Assignment of matrix channel %d to invalid output channel %d. %s\n",
412
                   ch, ch_assign, sample_message);
413
            return -1;
414
        }
415
        s->ch_assign[ch_assign] = ch;
416
    }
417

    
418
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
419

    
420
    if (checksum != get_bits(gbp, 8))
421
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
422

    
423
    /* Set default decoding parameters. */
424
    s->param_presence_flags   = 0xff;
425
    s->num_primitive_matrices = 0;
426
    s->blocksize              = 8;
427
    s->lossless_check_data    = 0;
428

    
429
    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
430
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
431

    
432
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
433
        ChannelParams *cp = &m->channel_params[ch];
434
        cp->filter_params[FIR].order = 0;
435
        cp->filter_params[IIR].order = 0;
436
        cp->filter_params[FIR].shift = 0;
437
        cp->filter_params[IIR].shift = 0;
438

    
439
        /* Default audio coding is 24-bit raw PCM. */
440
        cp->huff_offset      = 0;
441
        cp->sign_huff_offset = (-1) << 23;
442
        cp->codebook         = 0;
443
        cp->huff_lsbs        = 24;
444
    }
445

    
446
    if (substr == m->max_decoded_substream)
447
        m->avctx->channels = s->max_matrix_channel + 1;
448

    
449
    return 0;
450
}
451

    
452
/** Read parameters for one of the prediction filters. */
453

    
454
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
455
                              unsigned int channel, unsigned int filter)
456
{
457
    FilterParams *fp = &m->channel_params[channel].filter_params[filter];
458
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
459
    const char fchar = filter ? 'I' : 'F';
460
    int i, order;
461

    
462
    // Filter is 0 for FIR, 1 for IIR.
463
    assert(filter < 2);
464

    
465
    if (m->filter_changed[channel][filter]++ > 1) {
466
        av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
467
        return -1;
468
    }
469

    
470
    order = get_bits(gbp, 4);
471
    if (order > max_order) {
472
        av_log(m->avctx, AV_LOG_ERROR,
473
               "%cIR filter order %d is greater than maximum %d.\n",
474
               fchar, order, max_order);
475
        return -1;
476
    }
477
    fp->order = order;
478

    
479
    if (order > 0) {
480
        int coeff_bits, coeff_shift;
481

    
482
        fp->shift = get_bits(gbp, 4);
483

    
484
        coeff_bits  = get_bits(gbp, 5);
485
        coeff_shift = get_bits(gbp, 3);
486
        if (coeff_bits < 1 || coeff_bits > 16) {
487
            av_log(m->avctx, AV_LOG_ERROR,
488
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
489
                   fchar);
490
            return -1;
491
        }
492
        if (coeff_bits + coeff_shift > 16) {
493
            av_log(m->avctx, AV_LOG_ERROR,
494
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
495
                   fchar);
496
            return -1;
497
        }
498

    
499
        for (i = 0; i < order; i++)
500
            fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
501

    
502
        if (get_bits1(gbp)) {
503
            int state_bits, state_shift;
504

    
505
            if (filter == FIR) {
506
                av_log(m->avctx, AV_LOG_ERROR,
507
                       "FIR filter has state data specified.\n");
508
                return -1;
509
            }
510

    
511
            state_bits  = get_bits(gbp, 4);
512
            state_shift = get_bits(gbp, 4);
513

    
514
            /* TODO: Check validity of state data. */
515

    
516
            for (i = 0; i < order; i++)
517
                fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
518
        }
519
    }
520

    
521
    return 0;
522
}
523

    
524
/** Read parameters for primitive matrices. */
525

    
526
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
527
{
528
    SubStream *s = &m->substream[substr];
529
    unsigned int mat, ch;
530

    
531
    if (m->matrix_changed++ > 1) {
532
        av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
533
        return -1;
534
    }
535

    
536
    s->num_primitive_matrices = get_bits(gbp, 4);
537

    
538
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
539
        int frac_bits, max_chan;
540
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
541
        frac_bits             = get_bits(gbp, 4);
542
        s->lsb_bypass   [mat] = get_bits1(gbp);
543

    
544
        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
545
            av_log(m->avctx, AV_LOG_ERROR,
546
                    "Invalid channel %d specified as output from matrix.\n",
547
                    s->matrix_out_ch[mat]);
548
            return -1;
549
        }
550
        if (frac_bits > 14) {
551
            av_log(m->avctx, AV_LOG_ERROR,
552
                    "Too many fractional bits specified.\n");
553
            return -1;
554
        }
555

    
556
        max_chan = s->max_matrix_channel;
557
        if (!s->noise_type)
558
            max_chan+=2;
559

    
560
        for (ch = 0; ch <= max_chan; ch++) {
561
            int coeff_val = 0;
562
            if (get_bits1(gbp))
563
                coeff_val = get_sbits(gbp, frac_bits + 2);
564

    
565
            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
566
        }
567

    
568
        if (s->noise_type)
569
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
570
        else
571
            s->matrix_noise_shift[mat] = 0;
572
    }
573

    
574
    return 0;
575
}
576

    
577
/** Read channel parameters. */
578

    
579
static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
580
                               GetBitContext *gbp, unsigned int ch)
581
{
582
    ChannelParams *cp = &m->channel_params[ch];
583
    FilterParams *fir = &cp->filter_params[FIR];
584
    FilterParams *iir = &cp->filter_params[IIR];
585
    SubStream *s = &m->substream[substr];
586

    
587
    if (s->param_presence_flags & PARAM_FIR)
588
        if (get_bits1(gbp))
589
            if (read_filter_params(m, gbp, ch, FIR) < 0)
590
                return -1;
591

    
592
    if (s->param_presence_flags & PARAM_IIR)
593
        if (get_bits1(gbp))
594
            if (read_filter_params(m, gbp, ch, IIR) < 0)
595
                return -1;
596

    
597
    if (fir->order + iir->order > 8) {
598
        av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
599
        return -1;
600
    }
601

    
602
    if (fir->order && iir->order &&
603
        fir->shift != iir->shift) {
604
        av_log(m->avctx, AV_LOG_ERROR,
605
                "FIR and IIR filters must use the same precision.\n");
606
        return -1;
607
    }
608
    /* The FIR and IIR filters must have the same precision.
609
        * To simplify the filtering code, only the precision of the
610
        * FIR filter is considered. If only the IIR filter is employed,
611
        * the FIR filter precision is set to that of the IIR filter, so
612
        * that the filtering code can use it. */
613
    if (!fir->order && iir->order)
614
        fir->shift = iir->shift;
615

    
616
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
617
        if (get_bits1(gbp))
618
            cp->huff_offset = get_sbits(gbp, 15);
619

    
620
    cp->codebook  = get_bits(gbp, 2);
621
    cp->huff_lsbs = get_bits(gbp, 5);
622

    
623
    if (cp->huff_lsbs > 24) {
624
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
625
        return -1;
626
    }
627

    
628
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
629

    
630
    return 0;
631
}
632

    
633
/** Read decoding parameters that change more often than those in the restart
634
 *  header. */
635

    
636
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
637
                                unsigned int substr)
638
{
639
    SubStream *s = &m->substream[substr];
640
    unsigned int ch;
641

    
642
    if (s->param_presence_flags & PARAM_PRESENCE)
643
        if (get_bits1(gbp))
644
            s->param_presence_flags = get_bits(gbp, 8);
645

    
646
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
647
        if (get_bits1(gbp)) {
648
            s->blocksize = get_bits(gbp, 9);
649
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
650
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
651
                s->blocksize = 0;
652
                return -1;
653
            }
654
        }
655

    
656
    if (s->param_presence_flags & PARAM_MATRIX)
657
        if (get_bits1(gbp))
658
            if (read_matrix_params(m, substr, gbp) < 0)
659
                return -1;
660

    
661
    if (s->param_presence_flags & PARAM_OUTSHIFT)
662
        if (get_bits1(gbp))
663
            for (ch = 0; ch <= s->max_matrix_channel; ch++)
664
                s->output_shift[ch] = get_sbits(gbp, 4);
665

    
666
    if (s->param_presence_flags & PARAM_QUANTSTEP)
667
        if (get_bits1(gbp))
668
            for (ch = 0; ch <= s->max_channel; ch++) {
669
                ChannelParams *cp = &m->channel_params[ch];
670

    
671
                s->quant_step_size[ch] = get_bits(gbp, 4);
672

    
673
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
674
            }
675

    
676
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
677
        if (get_bits1(gbp))
678
            if (read_channel_params(m, substr, gbp, ch) < 0)
679
                return -1;
680

    
681
    return 0;
682
}
683

    
684
#define MSB_MASK(bits)  (-1u << bits)
685

    
686
/** Generate PCM samples using the prediction filters and residual values
687
 *  read from the data stream, and update the filter state. */
688

    
689
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
690
                           unsigned int channel)
691
{
692
    SubStream *s = &m->substream[substr];
693
    int32_t firbuf[MAX_BLOCKSIZE + MAX_FIR_ORDER];
694
    int32_t iirbuf[MAX_BLOCKSIZE + MAX_IIR_ORDER];
695
    FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
696
    FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
697
    unsigned int filter_shift = fir->shift;
698
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
699
    int index = MAX_BLOCKSIZE;
700
    int i;
701

    
702
    memcpy(&firbuf[index], fir->state, MAX_FIR_ORDER * sizeof(int32_t));
703
    memcpy(&iirbuf[index], iir->state, MAX_IIR_ORDER * sizeof(int32_t));
704

    
705
    for (i = 0; i < s->blocksize; i++) {
706
        int32_t residual = m->sample_buffer[i + s->blockpos][channel];
707
        unsigned int order;
708
        int64_t accum = 0;
709
        int32_t result;
710

    
711
        /* TODO: Move this code to DSPContext? */
712

    
713
        for (order = 0; order < fir->order; order++)
714
            accum += (int64_t) firbuf[index + order] * fir->coeff[order];
715
        for (order = 0; order < iir->order; order++)
716
            accum += (int64_t) iirbuf[index + order] * iir->coeff[order];
717

    
718
        accum  = accum >> filter_shift;
719
        result = (accum + residual) & mask;
720

    
721
        --index;
722

    
723
        firbuf[index] = result;
724
        iirbuf[index] = result - accum;
725

    
726
        m->sample_buffer[i + s->blockpos][channel] = result;
727
    }
728

    
729
    memcpy(fir->state, &firbuf[index], MAX_FIR_ORDER * sizeof(int32_t));
730
    memcpy(iir->state, &iirbuf[index], MAX_IIR_ORDER * sizeof(int32_t));
731
}
732

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

    
735
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
736
                           unsigned int substr)
737
{
738
    SubStream *s = &m->substream[substr];
739
    unsigned int i, ch, expected_stream_pos = 0;
740

    
741
    if (s->data_check_present) {
742
        expected_stream_pos  = get_bits_count(gbp);
743
        expected_stream_pos += get_bits(gbp, 16);
744
        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
745
               "we have not tested yet. %s\n", sample_message);
746
    }
747

    
748
    if (s->blockpos + s->blocksize > m->access_unit_size) {
749
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
750
        return -1;
751
    }
752

    
753
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
754
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
755

    
756
    for (i = 0; i < s->blocksize; i++)
757
        if (read_huff_channels(m, gbp, substr, i) < 0)
758
            return -1;
759

    
760
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
761
        filter_channel(m, substr, ch);
762

    
763
    s->blockpos += s->blocksize;
764

    
765
    if (s->data_check_present) {
766
        if (get_bits_count(gbp) != expected_stream_pos)
767
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
768
        skip_bits(gbp, 8);
769
    }
770

    
771
    return 0;
772
}
773

    
774
/** Data table used for TrueHD noise generation function. */
775

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

    
795
/** Noise generation functions.
796
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
797
 *  sequence generators, used to generate noise data which is used when the
798
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
799
 *  to compression, or just obfuscate the decoder. Are they for some kind of
800
 *  dithering? */
801

    
802
/** Generate two channels of noise, used in the matrix when
803
 *  restart sync word == 0x31ea. */
804

    
805
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
806
{
807
    SubStream *s = &m->substream[substr];
808
    unsigned int i;
809
    uint32_t seed = s->noisegen_seed;
810
    unsigned int maxchan = s->max_matrix_channel;
811

    
812
    for (i = 0; i < s->blockpos; i++) {
813
        uint16_t seed_shr7 = seed >> 7;
814
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
815
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
816

    
817
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
818
    }
819

    
820
    s->noisegen_seed = seed;
821
}
822

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

    
825
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
826
{
827
    SubStream *s = &m->substream[substr];
828
    unsigned int i;
829
    uint32_t seed = s->noisegen_seed;
830

    
831
    for (i = 0; i < m->access_unit_size_pow2; i++) {
832
        uint8_t seed_shr15 = seed >> 15;
833
        m->noise_buffer[i] = noise_table[seed_shr15];
834
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
835
    }
836

    
837
    s->noisegen_seed = seed;
838
}
839

    
840

    
841
/** Apply the channel matrices in turn to reconstruct the original audio
842
 *  samples. */
843

    
844
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
845
{
846
    SubStream *s = &m->substream[substr];
847
    unsigned int mat, src_ch, i;
848
    unsigned int maxchan;
849

    
850
    maxchan = s->max_matrix_channel;
851
    if (!s->noise_type) {
852
        generate_2_noise_channels(m, substr);
853
        maxchan += 2;
854
    } else {
855
        fill_noise_buffer(m, substr);
856
    }
857

    
858
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
859
        int matrix_noise_shift = s->matrix_noise_shift[mat];
860
        unsigned int dest_ch = s->matrix_out_ch[mat];
861
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
862
        int32_t *coeffs = s->matrix_coeff[mat];
863
        int index  = s->num_primitive_matrices - mat;
864
        int index2 = 2 * index + 1;
865

    
866
        /* TODO: DSPContext? */
867

    
868
        for (i = 0; i < s->blockpos; i++) {
869
            int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
870
            int32_t *samples = m->sample_buffer[i];
871
            int64_t accum = 0;
872

    
873
            for (src_ch = 0; src_ch <= maxchan; src_ch++)
874
                accum += (int64_t) samples[src_ch] * coeffs[src_ch];
875

    
876
            if (matrix_noise_shift) {
877
                index &= m->access_unit_size_pow2 - 1;
878
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
879
                index += index2;
880
            }
881

    
882
            samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
883
        }
884
    }
885
}
886

    
887
/** Write the audio data into the output buffer. */
888

    
889
static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
890
                                uint8_t *data, unsigned int *data_size, int is32)
891
{
892
    SubStream *s = &m->substream[substr];
893
    unsigned int i, out_ch = 0;
894
    int32_t *data_32 = (int32_t*) data;
895
    int16_t *data_16 = (int16_t*) data;
896

    
897
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
898
        return -1;
899

    
900
    for (i = 0; i < s->blockpos; i++) {
901
        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
902
            int mat_ch = s->ch_assign[out_ch];
903
            int32_t sample = m->sample_buffer[i][mat_ch]
904
                          << s->output_shift[mat_ch];
905
            s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
906
            if (is32) *data_32++ = sample << 8;
907
            else      *data_16++ = sample >> 8;
908
        }
909
    }
910

    
911
    *data_size = i * out_ch * (is32 ? 4 : 2);
912

    
913
    return 0;
914
}
915

    
916
static int output_data(MLPDecodeContext *m, unsigned int substr,
917
                       uint8_t *data, unsigned int *data_size)
918
{
919
    if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
920
        return output_data_internal(m, substr, data, data_size, 1);
921
    else
922
        return output_data_internal(m, substr, data, data_size, 0);
923
}
924

    
925

    
926
/** Read an access unit from the stream.
927
 *  Returns < 0 on error, 0 if not enough data is present in the input stream
928
 *  otherwise returns the number of bytes consumed. */
929

    
930
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
931
                            AVPacket *avpkt)
932
{
933
    const uint8_t *buf = avpkt->data;
934
    int buf_size = avpkt->size;
935
    MLPDecodeContext *m = avctx->priv_data;
936
    GetBitContext gb;
937
    unsigned int length, substr;
938
    unsigned int substream_start;
939
    unsigned int header_size = 4;
940
    unsigned int substr_header_size = 0;
941
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
942
    uint16_t substream_data_len[MAX_SUBSTREAMS];
943
    uint8_t parity_bits;
944

    
945
    if (buf_size < 4)
946
        return 0;
947

    
948
    length = (AV_RB16(buf) & 0xfff) * 2;
949

    
950
    if (length > buf_size)
951
        return -1;
952

    
953
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
954

    
955
    m->is_major_sync_unit = 0;
956
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
957
        if (read_major_sync(m, &gb) < 0)
958
            goto error;
959
        m->is_major_sync_unit = 1;
960
        header_size += 28;
961
    }
962

    
963
    if (!m->params_valid) {
964
        av_log(m->avctx, AV_LOG_WARNING,
965
               "Stream parameters not seen; skipping frame.\n");
966
        *data_size = 0;
967
        return length;
968
    }
969

    
970
    substream_start = 0;
971

    
972
    for (substr = 0; substr < m->num_substreams; substr++) {
973
        int extraword_present, checkdata_present, end, nonrestart_substr;
974

    
975
        extraword_present = get_bits1(&gb);
976
        nonrestart_substr = get_bits1(&gb);
977
        checkdata_present = get_bits1(&gb);
978
        skip_bits1(&gb);
979

    
980
        end = get_bits(&gb, 12) * 2;
981

    
982
        substr_header_size += 2;
983

    
984
        if (extraword_present) {
985
            if (m->avctx->codec_id == CODEC_ID_MLP) {
986
                av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
987
                goto error;
988
            }
989
            skip_bits(&gb, 16);
990
            substr_header_size += 2;
991
        }
992

    
993
        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
994
            av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
995
            goto error;
996
        }
997

    
998
        if (end + header_size + substr_header_size > length) {
999
            av_log(m->avctx, AV_LOG_ERROR,
1000
                   "Indicated length of substream %d data goes off end of "
1001
                   "packet.\n", substr);
1002
            end = length - header_size - substr_header_size;
1003
        }
1004

    
1005
        if (end < substream_start) {
1006
            av_log(avctx, AV_LOG_ERROR,
1007
                   "Indicated end offset of substream %d data "
1008
                   "is smaller than calculated start offset.\n",
1009
                   substr);
1010
            goto error;
1011
        }
1012

    
1013
        if (substr > m->max_decoded_substream)
1014
            continue;
1015

    
1016
        substream_parity_present[substr] = checkdata_present;
1017
        substream_data_len[substr] = end - substream_start;
1018
        substream_start = end;
1019
    }
1020

    
1021
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
1022
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1023

    
1024
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1025
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1026
        goto error;
1027
    }
1028

    
1029
    buf += header_size + substr_header_size;
1030

    
1031
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1032
        SubStream *s = &m->substream[substr];
1033
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1034

    
1035
        m->matrix_changed = 0;
1036
        memset(m->filter_changed, 0, sizeof(m->filter_changed));
1037

    
1038
        s->blockpos = 0;
1039
        do {
1040
            if (get_bits1(&gb)) {
1041
                if (get_bits1(&gb)) {
1042
                    /* A restart header should be present. */
1043
                    if (read_restart_header(m, &gb, buf, substr) < 0)
1044
                        goto next_substr;
1045
                    s->restart_seen = 1;
1046
                }
1047

    
1048
                if (!s->restart_seen)
1049
                    goto next_substr;
1050
                if (read_decoding_params(m, &gb, substr) < 0)
1051
                    goto next_substr;
1052
            }
1053

    
1054
            if (!s->restart_seen)
1055
                goto next_substr;
1056

    
1057
            if (read_block_data(m, &gb, substr) < 0)
1058
                return -1;
1059

    
1060
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1061
                goto substream_length_mismatch;
1062

    
1063
        } while (!get_bits1(&gb));
1064

    
1065
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1066

    
1067
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1068
            int shorten_by;
1069

    
1070
            if (get_bits(&gb, 16) != 0xD234)
1071
                return -1;
1072

    
1073
            shorten_by = get_bits(&gb, 16);
1074
            if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1075
                s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1076
            else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
1077
                return -1;
1078

    
1079
            if (substr == m->max_decoded_substream)
1080
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1081
        }
1082

    
1083
        if (substream_parity_present[substr]) {
1084
            uint8_t parity, checksum;
1085

    
1086
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1087
                goto substream_length_mismatch;
1088

    
1089
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1090
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1091

    
1092
            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1093
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1094
            if ( get_bits(&gb, 8)           != checksum)
1095
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1096
        }
1097

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

    
1101
next_substr:
1102
        if (!s->restart_seen)
1103
            av_log(m->avctx, AV_LOG_ERROR,
1104
                   "No restart header present in substream %d.\n", substr);
1105

    
1106
        buf += substream_data_len[substr];
1107
    }
1108

    
1109
    rematrix_channels(m, m->max_decoded_substream);
1110

    
1111
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1112
        return -1;
1113

    
1114
    return length;
1115

    
1116
substream_length_mismatch:
1117
    av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1118
    return -1;
1119

    
1120
error:
1121
    m->params_valid = 0;
1122
    return -1;
1123
}
1124

    
1125
#if CONFIG_MLP_DECODER
1126
AVCodec mlp_decoder = {
1127
    "mlp",
1128
    CODEC_TYPE_AUDIO,
1129
    CODEC_ID_MLP,
1130
    sizeof(MLPDecodeContext),
1131
    mlp_decode_init,
1132
    NULL,
1133
    NULL,
1134
    read_access_unit,
1135
    .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1136
};
1137
#endif /* CONFIG_MLP_DECODER */
1138

    
1139
#if CONFIG_TRUEHD_DECODER
1140
AVCodec truehd_decoder = {
1141
    "truehd",
1142
    CODEC_TYPE_AUDIO,
1143
    CODEC_ID_TRUEHD,
1144
    sizeof(MLPDecodeContext),
1145
    mlp_decode_init,
1146
    NULL,
1147
    NULL,
1148
    read_access_unit,
1149
    .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1150
};
1151
#endif /* CONFIG_TRUEHD_DECODER */