Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ 9106a698

History | View | Annotate | Download (37 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

    
339
    sync_word = get_bits(gbp, 13);
340

    
341
    if (sync_word != 0x31ea >> 1) {
342
        av_log(m->avctx, AV_LOG_ERROR,
343
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
344
        return -1;
345
    }
346
    s->noise_type = get_bits1(gbp);
347

    
348
    skip_bits(gbp, 16); /* Output timestamp */
349

    
350
    s->min_channel        = get_bits(gbp, 4);
351
    s->max_channel        = get_bits(gbp, 4);
352
    s->max_matrix_channel = get_bits(gbp, 4);
353

    
354
    if (s->min_channel > s->max_channel) {
355
        av_log(m->avctx, AV_LOG_ERROR,
356
               "Substream min channel cannot be greater than max channel.\n");
357
        return -1;
358
    }
359

    
360
    if (m->avctx->request_channels > 0
361
        && s->max_channel + 1 >= m->avctx->request_channels
362
        && substr < m->max_decoded_substream) {
363
        av_log(m->avctx, AV_LOG_INFO,
364
               "Extracting %d channel downmix from substream %d. "
365
               "Further substreams will be skipped.\n",
366
               s->max_channel + 1, substr);
367
        m->max_decoded_substream = substr;
368
    }
369

    
370
    s->noise_shift   = get_bits(gbp,  4);
371
    s->noisegen_seed = get_bits(gbp, 23);
372

    
373
    skip_bits(gbp, 19);
374

    
375
    s->data_check_present = get_bits1(gbp);
376
    lossless_check = get_bits(gbp, 8);
377
    if (substr == m->max_decoded_substream
378
        && s->lossless_check_data != 0xffffffff) {
379
        tmp = xor_32_to_8(s->lossless_check_data);
380
        if (tmp != lossless_check)
381
            av_log(m->avctx, AV_LOG_WARNING,
382
                   "Lossless check failed - expected %02x, calculated %02x.\n",
383
                   lossless_check, tmp);
384
    }
385

    
386
    skip_bits(gbp, 16);
387

    
388
    memset(s->ch_assign, 0, sizeof(s->ch_assign));
389

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

    
401
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
402

    
403
    if (checksum != get_bits(gbp, 8))
404
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
405

    
406
    /* Set default decoding parameters. */
407
    s->param_presence_flags   = 0xff;
408
    s->num_primitive_matrices = 0;
409
    s->blocksize              = 8;
410
    s->lossless_check_data    = 0;
411

    
412
    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
413
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
414

    
415
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
416
        ChannelParams *cp = &m->channel_params[ch];
417
        cp->filter_params[FIR].order = 0;
418
        cp->filter_params[IIR].order = 0;
419
        cp->filter_params[FIR].shift = 0;
420
        cp->filter_params[IIR].shift = 0;
421

    
422
        /* Default audio coding is 24-bit raw PCM. */
423
        cp->huff_offset      = 0;
424
        cp->sign_huff_offset = (-1) << 23;
425
        cp->codebook         = 0;
426
        cp->huff_lsbs        = 24;
427
    }
428

    
429
    if (substr == m->max_decoded_substream) {
430
        m->avctx->channels = s->max_matrix_channel + 1;
431
    }
432

    
433
    return 0;
434
}
435

    
436
/** Read parameters for one of the prediction filters. */
437

    
438
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
439
                              unsigned int channel, unsigned int filter)
440
{
441
    FilterParams *fp = &m->channel_params[channel].filter_params[filter];
442
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
443
    const char fchar = filter ? 'I' : 'F';
444
    int i, order;
445

    
446
    // Filter is 0 for FIR, 1 for IIR.
447
    assert(filter < 2);
448

    
449
    m->filter_changed[channel][filter]++;
450

    
451
    order = get_bits(gbp, 4);
452
    if (order > max_order) {
453
        av_log(m->avctx, AV_LOG_ERROR,
454
               "%cIR filter order %d is greater than maximum %d.\n",
455
               fchar, order, max_order);
456
        return -1;
457
    }
458
    fp->order = order;
459

    
460
    if (order > 0) {
461
        int coeff_bits, coeff_shift;
462

    
463
        fp->shift = get_bits(gbp, 4);
464

    
465
        coeff_bits  = get_bits(gbp, 5);
466
        coeff_shift = get_bits(gbp, 3);
467
        if (coeff_bits < 1 || coeff_bits > 16) {
468
            av_log(m->avctx, AV_LOG_ERROR,
469
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
470
                   fchar);
471
            return -1;
472
        }
473
        if (coeff_bits + coeff_shift > 16) {
474
            av_log(m->avctx, AV_LOG_ERROR,
475
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
476
                   fchar);
477
            return -1;
478
        }
479

    
480
        for (i = 0; i < order; i++)
481
            fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
482

    
483
        if (get_bits1(gbp)) {
484
            int state_bits, state_shift;
485

    
486
            if (filter == FIR) {
487
                av_log(m->avctx, AV_LOG_ERROR,
488
                       "FIR filter has state data specified.\n");
489
                return -1;
490
            }
491

    
492
            state_bits  = get_bits(gbp, 4);
493
            state_shift = get_bits(gbp, 4);
494

    
495
            /* TODO: Check validity of state data. */
496

    
497
            for (i = 0; i < order; i++)
498
                fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
499
        }
500
    }
501

    
502
    return 0;
503
}
504

    
505
/** Read parameters for primitive matrices. */
506

    
507
static int read_matrix_params(MLPDecodeContext *m, SubStream *s, GetBitContext *gbp)
508
{
509
    unsigned int mat, ch;
510

    
511
    s->num_primitive_matrices = get_bits(gbp, 4);
512
    m->matrix_changed++;
513

    
514
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
515
        int frac_bits, max_chan;
516
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
517
        frac_bits             = get_bits(gbp, 4);
518
        s->lsb_bypass   [mat] = get_bits1(gbp);
519

    
520
        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
521
            av_log(m->avctx, AV_LOG_ERROR,
522
                    "Invalid channel %d specified as output from matrix.\n",
523
                    s->matrix_out_ch[mat]);
524
            return -1;
525
        }
526
        if (frac_bits > 14) {
527
            av_log(m->avctx, AV_LOG_ERROR,
528
                    "Too many fractional bits specified.\n");
529
            return -1;
530
        }
531

    
532
        max_chan = s->max_matrix_channel;
533
        if (!s->noise_type)
534
            max_chan+=2;
535

    
536
        for (ch = 0; ch <= max_chan; ch++) {
537
            int coeff_val = 0;
538
            if (get_bits1(gbp))
539
                coeff_val = get_sbits(gbp, frac_bits + 2);
540

    
541
            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
542
        }
543

    
544
        if (s->noise_type)
545
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
546
        else
547
            s->matrix_noise_shift[mat] = 0;
548
    }
549

    
550
    return 0;
551
}
552

    
553
/** Read channel parameters. */
554

    
555
static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
556
                               GetBitContext *gbp, unsigned int ch)
557
{
558
    ChannelParams *cp = &m->channel_params[ch];
559
    FilterParams *fir = &cp->filter_params[FIR];
560
    FilterParams *iir = &cp->filter_params[IIR];
561
    SubStream *s = &m->substream[substr];
562

    
563
    if (s->param_presence_flags & PARAM_FIR)
564
        if (get_bits1(gbp))
565
            if (read_filter_params(m, gbp, ch, FIR) < 0)
566
                return -1;
567

    
568
    if (s->param_presence_flags & PARAM_IIR)
569
        if (get_bits1(gbp))
570
            if (read_filter_params(m, gbp, ch, IIR) < 0)
571
                return -1;
572

    
573
    if (fir->order + iir->order > 8) {
574
        av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
575
        return -1;
576
    }
577

    
578
    if (fir->order && iir->order &&
579
        fir->shift != iir->shift) {
580
        av_log(m->avctx, AV_LOG_ERROR,
581
                "FIR and IIR filters must use the same precision.\n");
582
        return -1;
583
    }
584
    /* The FIR and IIR filters must have the same precision.
585
        * To simplify the filtering code, only the precision of the
586
        * FIR filter is considered. If only the IIR filter is employed,
587
        * the FIR filter precision is set to that of the IIR filter, so
588
        * that the filtering code can use it. */
589
    if (!fir->order && iir->order)
590
        fir->shift = iir->shift;
591

    
592
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
593
        if (get_bits1(gbp))
594
            cp->huff_offset = get_sbits(gbp, 15);
595

    
596
    cp->codebook  = get_bits(gbp, 2);
597
    cp->huff_lsbs = get_bits(gbp, 5);
598

    
599
    if (cp->huff_lsbs > 24) {
600
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
601
        return -1;
602
    }
603

    
604
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
605

    
606
    return 0;
607
}
608

    
609
/** Read decoding parameters that change more often than those in the restart
610
 *  header. */
611

    
612
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
613
                                unsigned int substr)
614
{
615
    SubStream *s = &m->substream[substr];
616
    unsigned int ch;
617

    
618
    if (s->param_presence_flags & PARAM_PRESENCE)
619
    if (get_bits1(gbp))
620
        s->param_presence_flags = get_bits(gbp, 8);
621

    
622
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
623
        if (get_bits1(gbp)) {
624
            s->blocksize = get_bits(gbp, 9);
625
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
626
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
627
                s->blocksize = 0;
628
                return -1;
629
            }
630
        }
631

    
632
    if (s->param_presence_flags & PARAM_MATRIX)
633
        if (get_bits1(gbp)) {
634
            if (read_matrix_params(m, s, gbp) < 0)
635
                return -1;
636
        }
637

    
638
    if (s->param_presence_flags & PARAM_OUTSHIFT)
639
        if (get_bits1(gbp))
640
            for (ch = 0; ch <= s->max_matrix_channel; ch++) {
641
                s->output_shift[ch] = get_sbits(gbp, 4);
642
            }
643

    
644
    if (s->param_presence_flags & PARAM_QUANTSTEP)
645
        if (get_bits1(gbp))
646
            for (ch = 0; ch <= s->max_channel; ch++) {
647
                ChannelParams *cp = &m->channel_params[ch];
648

    
649
                s->quant_step_size[ch] = get_bits(gbp, 4);
650

    
651
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
652
            }
653

    
654
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
655
        if (get_bits1(gbp)) {
656
            if (read_channel_params(m, substr, gbp, ch) < 0)
657
                return -1;
658
        }
659

    
660
    return 0;
661
}
662

    
663
#define MSB_MASK(bits)  (-1u << bits)
664

    
665
/** Generate PCM samples using the prediction filters and residual values
666
 *  read from the data stream, and update the filter state. */
667

    
668
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
669
                           unsigned int channel)
670
{
671
    SubStream *s = &m->substream[substr];
672
    int32_t firbuf[MAX_BLOCKSIZE + MAX_FIR_ORDER];
673
    int32_t iirbuf[MAX_BLOCKSIZE + MAX_IIR_ORDER];
674
    FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
675
    FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
676
    unsigned int filter_shift = fir->shift;
677
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
678
    int index = MAX_BLOCKSIZE;
679
    int i;
680

    
681
    memcpy(&firbuf[index], fir->state, MAX_FIR_ORDER * sizeof(int32_t));
682
    memcpy(&iirbuf[index], iir->state, MAX_IIR_ORDER * sizeof(int32_t));
683

    
684
    for (i = 0; i < s->blocksize; i++) {
685
        int32_t residual = m->sample_buffer[i + s->blockpos][channel];
686
        unsigned int order;
687
        int64_t accum = 0;
688
        int32_t result;
689

    
690
        /* TODO: Move this code to DSPContext? */
691

    
692
        for (order = 0; order < fir->order; order++)
693
            accum += (int64_t) firbuf[index + order] * fir->coeff[order];
694
        for (order = 0; order < iir->order; order++)
695
            accum += (int64_t) iirbuf[index + order] * iir->coeff[order];
696

    
697
        accum  = accum >> filter_shift;
698
        result = (accum + residual) & mask;
699

    
700
        --index;
701

    
702
        firbuf[index] = result;
703
        iirbuf[index] = result - accum;
704

    
705
        m->sample_buffer[i + s->blockpos][channel] = result;
706
    }
707

    
708
    memcpy(fir->state, &firbuf[index], MAX_FIR_ORDER * sizeof(int32_t));
709
    memcpy(iir->state, &iirbuf[index], MAX_IIR_ORDER * sizeof(int32_t));
710
}
711

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

    
714
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
715
                           unsigned int substr)
716
{
717
    SubStream *s = &m->substream[substr];
718
    unsigned int i, ch, expected_stream_pos = 0;
719

    
720
    if (s->data_check_present) {
721
        expected_stream_pos  = get_bits_count(gbp);
722
        expected_stream_pos += get_bits(gbp, 16);
723
        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
724
               "we have not tested yet. %s\n", sample_message);
725
    }
726

    
727
    if (s->blockpos + s->blocksize > m->access_unit_size) {
728
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
729
        return -1;
730
    }
731

    
732
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
733
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
734

    
735
    for (i = 0; i < s->blocksize; i++) {
736
        if (read_huff_channels(m, gbp, substr, i) < 0)
737
            return -1;
738
    }
739

    
740
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
741
        filter_channel(m, substr, ch);
742
    }
743

    
744
    s->blockpos += s->blocksize;
745

    
746
    if (s->data_check_present) {
747
        if (get_bits_count(gbp) != expected_stream_pos)
748
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
749
        skip_bits(gbp, 8);
750
    }
751

    
752
    return 0;
753
}
754

    
755
/** Data table used for TrueHD noise generation function. */
756

    
757
static const int8_t noise_table[256] = {
758
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
759
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
760
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
761
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
762
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
763
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
764
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
765
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
766
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
767
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
768
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
769
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
770
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
771
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
772
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
773
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
774
};
775

    
776
/** Noise generation functions.
777
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
778
 *  sequence generators, used to generate noise data which is used when the
779
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
780
 *  to compression, or just obfuscate the decoder. Are they for some kind of
781
 *  dithering? */
782

    
783
/** Generate two channels of noise, used in the matrix when
784
 *  restart sync word == 0x31ea. */
785

    
786
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
787
{
788
    SubStream *s = &m->substream[substr];
789
    unsigned int i;
790
    uint32_t seed = s->noisegen_seed;
791
    unsigned int maxchan = s->max_matrix_channel;
792

    
793
    for (i = 0; i < s->blockpos; i++) {
794
        uint16_t seed_shr7 = seed >> 7;
795
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
796
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
797

    
798
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
799
    }
800

    
801
    s->noisegen_seed = seed;
802
}
803

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

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

    
812
    for (i = 0; i < m->access_unit_size_pow2; i++) {
813
        uint8_t seed_shr15 = seed >> 15;
814
        m->noise_buffer[i] = noise_table[seed_shr15];
815
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
816
    }
817

    
818
    s->noisegen_seed = seed;
819
}
820

    
821

    
822
/** Apply the channel matrices in turn to reconstruct the original audio
823
 *  samples. */
824

    
825
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
826
{
827
    SubStream *s = &m->substream[substr];
828
    unsigned int mat, src_ch, i;
829
    unsigned int maxchan;
830

    
831
    maxchan = s->max_matrix_channel;
832
    if (!s->noise_type) {
833
        generate_2_noise_channels(m, substr);
834
        maxchan += 2;
835
    } else {
836
        fill_noise_buffer(m, substr);
837
    }
838

    
839
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
840
        int matrix_noise_shift = s->matrix_noise_shift[mat];
841
        unsigned int dest_ch = s->matrix_out_ch[mat];
842
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
843

    
844
        /* TODO: DSPContext? */
845

    
846
        for (i = 0; i < s->blockpos; i++) {
847
            int64_t accum = 0;
848
            for (src_ch = 0; src_ch <= maxchan; src_ch++) {
849
                accum += (int64_t)m->sample_buffer[i][src_ch]
850
                                  * s->matrix_coeff[mat][src_ch];
851
            }
852
            if (matrix_noise_shift) {
853
                uint32_t index = s->num_primitive_matrices - mat;
854
                index = (i * (index * 2 + 1) + index) & (m->access_unit_size_pow2 - 1);
855
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
856
            }
857
            m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
858
                                             + m->bypassed_lsbs[i][mat];
859
        }
860
    }
861
}
862

    
863
/** Write the audio data into the output buffer. */
864

    
865
static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
866
                                uint8_t *data, unsigned int *data_size, int is32)
867
{
868
    SubStream *s = &m->substream[substr];
869
    unsigned int i, out_ch = 0;
870
    int32_t *data_32 = (int32_t*) data;
871
    int16_t *data_16 = (int16_t*) data;
872

    
873
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
874
        return -1;
875

    
876
    for (i = 0; i < s->blockpos; i++) {
877
        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
878
            int mat_ch = s->ch_assign[out_ch];
879
            int32_t sample = m->sample_buffer[i][mat_ch]
880
                          << s->output_shift[mat_ch];
881
            s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
882
            if (is32) *data_32++ = sample << 8;
883
            else      *data_16++ = sample >> 8;
884
        }
885
    }
886

    
887
    *data_size = i * out_ch * (is32 ? 4 : 2);
888

    
889
    return 0;
890
}
891

    
892
static int output_data(MLPDecodeContext *m, unsigned int substr,
893
                       uint8_t *data, unsigned int *data_size)
894
{
895
    if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
896
        return output_data_internal(m, substr, data, data_size, 1);
897
    else
898
        return output_data_internal(m, substr, data, data_size, 0);
899
}
900

    
901

    
902
/** Read an access unit from the stream.
903
 *  Returns < 0 on error, 0 if not enough data is present in the input stream
904
 *  otherwise returns the number of bytes consumed. */
905

    
906
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
907
                            AVPacket *avpkt)
908
{
909
    const uint8_t *buf = avpkt->data;
910
    int buf_size = avpkt->size;
911
    MLPDecodeContext *m = avctx->priv_data;
912
    GetBitContext gb;
913
    unsigned int length, substr;
914
    unsigned int substream_start;
915
    unsigned int header_size = 4;
916
    unsigned int substr_header_size = 0;
917
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
918
    uint16_t substream_data_len[MAX_SUBSTREAMS];
919
    uint8_t parity_bits;
920

    
921
    if (buf_size < 4)
922
        return 0;
923

    
924
    length = (AV_RB16(buf) & 0xfff) * 2;
925

    
926
    if (length > buf_size)
927
        return -1;
928

    
929
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
930

    
931
    m->is_major_sync_unit = 0;
932
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
933
        if (read_major_sync(m, &gb) < 0)
934
            goto error;
935
        m->is_major_sync_unit = 1;
936
        header_size += 28;
937
    }
938

    
939
    if (!m->params_valid) {
940
        av_log(m->avctx, AV_LOG_WARNING,
941
               "Stream parameters not seen; skipping frame.\n");
942
        *data_size = 0;
943
        return length;
944
    }
945

    
946
    substream_start = 0;
947

    
948
    for (substr = 0; substr < m->num_substreams; substr++) {
949
        int extraword_present, checkdata_present, end, nonrestart_substr;
950

    
951
        extraword_present = get_bits1(&gb);
952
        nonrestart_substr = get_bits1(&gb);
953
        checkdata_present = get_bits1(&gb);
954
        skip_bits1(&gb);
955

    
956
        end = get_bits(&gb, 12) * 2;
957

    
958
        substr_header_size += 2;
959

    
960
        if (extraword_present) {
961
            if (m->avctx->codec_id == CODEC_ID_MLP) {
962
                av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
963
                goto error;
964
            }
965
            skip_bits(&gb, 16);
966
            substr_header_size += 2;
967
        }
968

    
969
        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
970
            av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
971
            goto error;
972
        }
973

    
974
        if (end + header_size + substr_header_size > length) {
975
            av_log(m->avctx, AV_LOG_ERROR,
976
                   "Indicated length of substream %d data goes off end of "
977
                   "packet.\n", substr);
978
            end = length - header_size - substr_header_size;
979
        }
980

    
981
        if (end < substream_start) {
982
            av_log(avctx, AV_LOG_ERROR,
983
                   "Indicated end offset of substream %d data "
984
                   "is smaller than calculated start offset.\n",
985
                   substr);
986
            goto error;
987
        }
988

    
989
        if (substr > m->max_decoded_substream)
990
            continue;
991

    
992
        substream_parity_present[substr] = checkdata_present;
993
        substream_data_len[substr] = end - substream_start;
994
        substream_start = end;
995
    }
996

    
997
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
998
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
999

    
1000
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1001
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1002
        goto error;
1003
    }
1004

    
1005
    buf += header_size + substr_header_size;
1006

    
1007
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1008
        SubStream *s = &m->substream[substr];
1009
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1010

    
1011
        m->matrix_changed = 0;
1012
        memset(m->filter_changed, 0, sizeof(m->filter_changed));
1013

    
1014
        s->blockpos = 0;
1015
        do {
1016
            unsigned int ch;
1017

    
1018
            if (get_bits1(&gb)) {
1019
                if (get_bits1(&gb)) {
1020
                    /* A restart header should be present. */
1021
                    if (read_restart_header(m, &gb, buf, substr) < 0)
1022
                        goto next_substr;
1023
                    s->restart_seen = 1;
1024
                }
1025

    
1026
                if (!s->restart_seen) {
1027
                    goto next_substr;
1028
                }
1029

    
1030
                if (read_decoding_params(m, &gb, substr) < 0)
1031
                    goto next_substr;
1032
            }
1033

    
1034
            if (m->matrix_changed > 1) {
1035
                av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
1036
                goto next_substr;
1037
            }
1038
            for (ch = 0; ch < s->max_channel; ch++)
1039
                if (m->filter_changed[ch][FIR] > 1 ||
1040
                    m->filter_changed[ch][IIR] > 1) {
1041
                    av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
1042
                    goto next_substr;
1043
                }
1044

    
1045
            if (!s->restart_seen) {
1046
                goto next_substr;
1047
            }
1048

    
1049
            if (read_block_data(m, &gb, substr) < 0)
1050
                return -1;
1051

    
1052
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1053
                goto substream_length_mismatch;
1054

    
1055
        } while (!get_bits1(&gb));
1056

    
1057
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1058
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1059
            int shorten_by;
1060

    
1061
            if (get_bits(&gb, 16) != 0xD234)
1062
                return -1;
1063

    
1064
            shorten_by = get_bits(&gb, 16);
1065
            if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1066
                s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1067
            else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
1068
                return -1;
1069

    
1070
            if (substr == m->max_decoded_substream)
1071
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1072
        }
1073
        if (substream_parity_present[substr]) {
1074
            uint8_t parity, checksum;
1075

    
1076
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1077
                goto substream_length_mismatch;
1078

    
1079
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1080
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1081

    
1082
            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1083
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1084
            if ( get_bits(&gb, 8)           != checksum)
1085
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1086
        }
1087
        if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
1088
            goto substream_length_mismatch;
1089
        }
1090

    
1091
next_substr:
1092
        if (!s->restart_seen) {
1093
            av_log(m->avctx, AV_LOG_ERROR,
1094
                   "No restart header present in substream %d.\n", substr);
1095
        }
1096

    
1097
        buf += substream_data_len[substr];
1098
    }
1099

    
1100
    rematrix_channels(m, m->max_decoded_substream);
1101

    
1102
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1103
        return -1;
1104

    
1105
    return length;
1106

    
1107
substream_length_mismatch:
1108
    av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1109
    return -1;
1110

    
1111
error:
1112
    m->params_valid = 0;
1113
    return -1;
1114
}
1115

    
1116
#if CONFIG_MLP_DECODER
1117
AVCodec mlp_decoder = {
1118
    "mlp",
1119
    CODEC_TYPE_AUDIO,
1120
    CODEC_ID_MLP,
1121
    sizeof(MLPDecodeContext),
1122
    mlp_decode_init,
1123
    NULL,
1124
    NULL,
1125
    read_access_unit,
1126
    .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1127
};
1128
#endif /* CONFIG_MLP_DECODER */
1129

    
1130
#if CONFIG_TRUEHD_DECODER
1131
AVCodec truehd_decoder = {
1132
    "truehd",
1133
    CODEC_TYPE_AUDIO,
1134
    CODEC_ID_TRUEHD,
1135
    sizeof(MLPDecodeContext),
1136
    mlp_decode_init,
1137
    NULL,
1138
    NULL,
1139
    read_access_unit,
1140
    .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1141
};
1142
#endif /* CONFIG_TRUEHD_DECODER */