Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ ce15710f

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

    
27
#include <stdint.h>
28

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

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

    
40

    
41
static const char* sample_message =
42
    "Please file a bug report following the instructions at "
43
    "http://ffmpeg.mplayerhq.hu/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

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

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

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

    
81
    //@{
82
    /** matrix data */
83

    
84
    //! Number of matrices to be applied.
85
    uint8_t     num_primitive_matrices;
86

    
87
    //! matrix output channel
88
    uint8_t     matrix_out_ch[MAX_MATRICES];
89

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

    
98
    //! Left shift to apply to Huffman-decoded residuals.
99
    uint8_t     quant_step_size[MAX_CHANNELS];
100

    
101
    //! number of PCM samples in current audio block
102
    uint16_t    blocksize;
103
    //! Number of PCM samples decoded so far in this frame.
104
    uint16_t    blockpos;
105

    
106
    //! Left shift to apply to decoded PCM values to get final 24-bit output.
107
    int8_t      output_shift[MAX_CHANNELS];
108

    
109
    //! Running XOR of all output samples.
110
    int32_t     lossless_check_data;
111

    
112
} SubStream;
113

    
114
typedef struct MLPDecodeContext {
115
    AVCodecContext *avctx;
116

    
117
    //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
118
    uint8_t     params_valid;
119

    
120
    //! Number of substreams contained within this stream.
121
    uint8_t     num_substreams;
122

    
123
    //! Index of the last substream to decode - further substreams are skipped.
124
    uint8_t     max_decoded_substream;
125

    
126
    //! number of PCM samples contained in each frame
127
    int         access_unit_size;
128
    //! next power of two above the number of samples in each frame
129
    int         access_unit_size_pow2;
130

    
131
    SubStream   substream[MAX_SUBSTREAMS];
132

    
133
    ChannelParams channel_params[MAX_CHANNELS];
134

    
135
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
136
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
137
    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS+2];
138
} MLPDecodeContext;
139

    
140
static VLC huff_vlc[3];
141

    
142
/** Initialize static data, constant between all invocations of the codec. */
143

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

    
156
    ff_mlp_init_crc();
157
}
158

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

    
168
    if (cp->codebook > 0)
169
        sign_huff_offset -= 7 << lsb_bits;
170

    
171
    if (sign_shift >= 0)
172
        sign_huff_offset -= 1 << sign_shift;
173

    
174
    return sign_huff_offset;
175
}
176

    
177
/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
178
 *  and plain LSBs. */
179

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

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

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

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

    
201
        if (result < 0)
202
            return -1;
203

    
204
        if (lsb_bits > 0)
205
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
206

    
207
        result  += cp->sign_huff_offset;
208
        result <<= quant_step_size;
209

    
210
        m->sample_buffer[pos + s->blockpos][channel] = result;
211
    }
212

    
213
    return 0;
214
}
215

    
216
static av_cold int mlp_decode_init(AVCodecContext *avctx)
217
{
218
    MLPDecodeContext *m = avctx->priv_data;
219
    int substr;
220

    
221
    init_static();
222
    m->avctx = avctx;
223
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
224
        m->substream[substr].lossless_check_data = 0xffffffff;
225
    avctx->sample_fmt = SAMPLE_FMT_S16;
226
    return 0;
227
}
228

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

    
234
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
235
{
236
    MLPHeaderInfo mh;
237
    int substr;
238

    
239
    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
240
        return -1;
241

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

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

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

    
281
    if (mh.num_substreams == 0)
282
        return -1;
283
    if (mh.num_substreams > MAX_SUBSTREAMS) {
284
        av_log(m->avctx, AV_LOG_ERROR,
285
               "Number of substreams %d is larger than the maximum supported "
286
               "by the decoder. %s\n", mh.num_substreams, sample_message);
287
        return -1;
288
    }
289

    
290
    m->access_unit_size      = mh.access_unit_size;
291
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;
292

    
293
    m->num_substreams        = mh.num_substreams;
294
    m->max_decoded_substream = m->num_substreams - 1;
295

    
296
    m->avctx->sample_rate    = mh.group1_samplerate;
297
    m->avctx->frame_size     = mh.access_unit_size;
298

    
299
#ifdef CONFIG_AUDIO_NONSHORT
300
    m->avctx->bits_per_sample = mh.group1_bits;
301
    if (mh.group1_bits > 16) {
302
        m->avctx->sample_fmt = SAMPLE_FMT_S32;
303
    }
304
#endif
305

    
306
    m->params_valid = 1;
307
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
308
        m->substream[substr].restart_seen = 0;
309

    
310
    return 0;
311
}
312

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

    
317
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
318
                               const uint8_t *buf, unsigned int substr)
319
{
320
    SubStream *s = &m->substream[substr];
321
    unsigned int ch;
322
    int sync_word, tmp;
323
    uint8_t checksum;
324
    uint8_t lossless_check;
325
    int start_count = get_bits_count(gbp);
326

    
327
    sync_word = get_bits(gbp, 13);
328

    
329
    if (sync_word != 0x31ea >> 1) {
330
        av_log(m->avctx, AV_LOG_ERROR,
331
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
332
        return -1;
333
    }
334
    s->noise_type = get_bits1(gbp);
335

    
336
    skip_bits(gbp, 16); /* Output timestamp */
337

    
338
    s->min_channel        = get_bits(gbp, 4);
339
    s->max_channel        = get_bits(gbp, 4);
340
    s->max_matrix_channel = get_bits(gbp, 4);
341

    
342
    if (s->min_channel > s->max_channel) {
343
        av_log(m->avctx, AV_LOG_ERROR,
344
               "Substream min channel cannot be greater than max channel.\n");
345
        return -1;
346
    }
347

    
348
    if (m->avctx->request_channels > 0
349
        && s->max_channel + 1 >= m->avctx->request_channels
350
        && substr < m->max_decoded_substream) {
351
        av_log(m->avctx, AV_LOG_INFO,
352
               "Extracting %d channel downmix from substream %d. "
353
               "Further substreams will be skipped.\n",
354
               s->max_channel + 1, substr);
355
        m->max_decoded_substream = substr;
356
    }
357

    
358
    s->noise_shift   = get_bits(gbp,  4);
359
    s->noisegen_seed = get_bits(gbp, 23);
360

    
361
    skip_bits(gbp, 19);
362

    
363
    s->data_check_present = get_bits1(gbp);
364
    lossless_check = get_bits(gbp, 8);
365
    if (substr == m->max_decoded_substream
366
        && s->lossless_check_data != 0xffffffff) {
367
        tmp = s->lossless_check_data;
368
        tmp ^= tmp >> 16;
369
        tmp ^= tmp >> 8;
370
        tmp &= 0xff;
371
        if (tmp != lossless_check)
372
            av_log(m->avctx, AV_LOG_WARNING,
373
                   "Lossless check failed - expected %02x, calculated %02x.\n",
374
                   lossless_check, tmp);
375
        else
376
            dprintf(m->avctx, "Lossless check passed for substream %d (%x).\n",
377
                    substr, tmp);
378
    }
379

    
380
    skip_bits(gbp, 16);
381

    
382
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
383
        int ch_assign = get_bits(gbp, 6);
384
        dprintf(m->avctx, "ch_assign[%d][%d] = %d\n", substr, ch,
385
                ch_assign);
386
        if (ch_assign != ch) {
387
            av_log(m->avctx, AV_LOG_ERROR,
388
                   "Non-1:1 channel assignments are used in this stream. %s\n",
389
                   sample_message);
390
            return -1;
391
        }
392
    }
393

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

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

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

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

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

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

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

    
426
    return 0;
427
}
428

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

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

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

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

    
450
    if (order > 0) {
451
        int coeff_bits, coeff_shift;
452

    
453
        fp->shift = get_bits(gbp, 4);
454

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

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

    
473
        if (get_bits1(gbp)) {
474
            int state_bits, state_shift;
475

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

    
482
            state_bits  = get_bits(gbp, 4);
483
            state_shift = get_bits(gbp, 4);
484

    
485
            /* TODO: Check validity of state data. */
486

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

    
492
    return 0;
493
}
494

    
495
/** Read decoding parameters that change more often than those in the restart
496
 *  header. */
497

    
498
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
499
                                unsigned int substr)
500
{
501
    SubStream *s = &m->substream[substr];
502
    unsigned int mat, ch;
503

    
504
    if (get_bits1(gbp))
505
        s->param_presence_flags = get_bits(gbp, 8);
506

    
507
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
508
        if (get_bits1(gbp)) {
509
            s->blocksize = get_bits(gbp, 9);
510
            if (s->blocksize > MAX_BLOCKSIZE) {
511
                av_log(m->avctx, AV_LOG_ERROR, "block size too large\n");
512
                s->blocksize = 0;
513
                return -1;
514
            }
515
        }
516

    
517
    if (s->param_presence_flags & PARAM_MATRIX)
518
        if (get_bits1(gbp)) {
519
            s->num_primitive_matrices = get_bits(gbp, 4);
520

    
521
            for (mat = 0; mat < s->num_primitive_matrices; mat++) {
522
                int frac_bits, max_chan;
523
                s->matrix_out_ch[mat] = get_bits(gbp, 4);
524
                frac_bits             = get_bits(gbp, 4);
525
                s->lsb_bypass   [mat] = get_bits1(gbp);
526

    
527
                if (s->matrix_out_ch[mat] > s->max_channel) {
528
                    av_log(m->avctx, AV_LOG_ERROR,
529
                           "Invalid channel %d specified as output from matrix.\n",
530
                           s->matrix_out_ch[mat]);
531
                    return -1;
532
                }
533
                if (frac_bits > 14) {
534
                    av_log(m->avctx, AV_LOG_ERROR,
535
                           "Too many fractional bits specified.\n");
536
                    return -1;
537
                }
538

    
539
                max_chan = s->max_matrix_channel;
540
                if (!s->noise_type)
541
                    max_chan+=2;
542

    
543
                for (ch = 0; ch <= max_chan; ch++) {
544
                    int coeff_val = 0;
545
                    if (get_bits1(gbp))
546
                        coeff_val = get_sbits(gbp, frac_bits + 2);
547

    
548
                    s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
549
                }
550

    
551
                if (s->noise_type)
552
                    s->matrix_noise_shift[mat] = get_bits(gbp, 4);
553
                else
554
                    s->matrix_noise_shift[mat] = 0;
555
            }
556
        }
557

    
558
    if (s->param_presence_flags & PARAM_OUTSHIFT)
559
        if (get_bits1(gbp))
560
            for (ch = 0; ch <= s->max_matrix_channel; ch++) {
561
                s->output_shift[ch] = get_bits(gbp, 4);
562
                dprintf(m->avctx, "output shift[%d] = %d\n",
563
                        ch, s->output_shift[ch]);
564
                /* TODO: validate */
565
            }
566

    
567
    if (s->param_presence_flags & PARAM_QUANTSTEP)
568
        if (get_bits1(gbp))
569
            for (ch = 0; ch <= s->max_channel; ch++) {
570
                ChannelParams *cp = &m->channel_params[ch];
571

    
572
                s->quant_step_size[ch] = get_bits(gbp, 4);
573
                /* TODO: validate */
574

    
575
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
576
            }
577

    
578
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
579
        if (get_bits1(gbp)) {
580
            ChannelParams *cp = &m->channel_params[ch];
581
            FilterParams *fir = &cp->filter_params[FIR];
582
            FilterParams *iir = &cp->filter_params[IIR];
583

    
584
            if (s->param_presence_flags & PARAM_FIR)
585
                if (get_bits1(gbp))
586
                    if (read_filter_params(m, gbp, ch, FIR) < 0)
587
                        return -1;
588

    
589
            if (s->param_presence_flags & PARAM_IIR)
590
                if (get_bits1(gbp))
591
                    if (read_filter_params(m, gbp, ch, IIR) < 0)
592
                        return -1;
593

    
594
            if (fir->order && iir->order &&
595
                fir->shift != iir->shift) {
596
                av_log(m->avctx, AV_LOG_ERROR,
597
                       "FIR and IIR filters must use the same precision.\n");
598
                return -1;
599
            }
600
            /* The FIR and IIR filters must have the same precision.
601
             * To simplify the filtering code, only the precision of the
602
             * FIR filter is considered. If only the IIR filter is employed,
603
             * the FIR filter precision is set to that of the IIR filter, so
604
             * that the filtering code can use it. */
605
            if (!fir->order && iir->order)
606
                fir->shift = iir->shift;
607

    
608
            if (s->param_presence_flags & PARAM_HUFFOFFSET)
609
                if (get_bits1(gbp))
610
                    cp->huff_offset = get_sbits(gbp, 15);
611

    
612
            cp->codebook  = get_bits(gbp, 2);
613
            cp->huff_lsbs = get_bits(gbp, 5);
614

    
615
            cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
616

    
617
            /* TODO: validate */
618
        }
619

    
620
    return 0;
621
}
622

    
623
#define MSB_MASK(bits)  (-1u << bits)
624

    
625
/** Generate PCM samples using the prediction filters and residual values
626
 *  read from the data stream, and update the filter state. */
627

    
628
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
629
                           unsigned int channel)
630
{
631
    SubStream *s = &m->substream[substr];
632
    int32_t filter_state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FILTER_ORDER];
633
    FilterParams *fp[NUM_FILTERS] = { &m->channel_params[channel].filter_params[FIR],
634
                                      &m->channel_params[channel].filter_params[IIR], };
635
    unsigned int filter_shift = fp[FIR]->shift;
636
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
637
    int index = MAX_BLOCKSIZE;
638
    int j, i;
639

    
640
    for (j = 0; j < NUM_FILTERS; j++) {
641
        memcpy(&filter_state_buffer[j][MAX_BLOCKSIZE], &fp[j]->state[0],
642
               MAX_FILTER_ORDER * sizeof(int32_t));
643
    }
644

    
645
    for (i = 0; i < s->blocksize; i++) {
646
        int32_t residual = m->sample_buffer[i + s->blockpos][channel];
647
        unsigned int order;
648
        int64_t accum = 0;
649
        int32_t result;
650

    
651
        /* TODO: Move this code to DSPContext? */
652

    
653
        for (j = 0; j < NUM_FILTERS; j++)
654
            for (order = 0; order < fp[j]->order; order++)
655
                accum += (int64_t)filter_state_buffer[j][index + order] *
656
                                  fp[j]->coeff[order];
657

    
658
        accum  = accum >> filter_shift;
659
        result = (accum + residual) & mask;
660

    
661
        --index;
662

    
663
        filter_state_buffer[FIR][index] = result;
664
        filter_state_buffer[IIR][index] = result - accum;
665

    
666
        m->sample_buffer[i + s->blockpos][channel] = result;
667
    }
668

    
669
    for (j = 0; j < NUM_FILTERS; j++) {
670
        memcpy(&fp[j]->state[0], &filter_state_buffer[j][index],
671
               MAX_FILTER_ORDER * sizeof(int32_t));
672
    }
673
}
674

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

    
677
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
678
                           unsigned int substr)
679
{
680
    SubStream *s = &m->substream[substr];
681
    unsigned int i, ch, expected_stream_pos = 0;
682

    
683
    if (s->data_check_present) {
684
        expected_stream_pos  = get_bits_count(gbp);
685
        expected_stream_pos += get_bits(gbp, 16);
686
        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
687
               "we have not tested yet. %s\n", sample_message);
688
    }
689

    
690
    if (s->blockpos + s->blocksize > m->access_unit_size) {
691
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
692
        return -1;
693
    }
694

    
695
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
696
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
697

    
698
    for (i = 0; i < s->blocksize; i++) {
699
        if (read_huff_channels(m, gbp, substr, i) < 0)
700
            return -1;
701
    }
702

    
703
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
704
        filter_channel(m, substr, ch);
705
    }
706

    
707
    s->blockpos += s->blocksize;
708

    
709
    if (s->data_check_present) {
710
        if (get_bits_count(gbp) != expected_stream_pos)
711
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
712
        skip_bits(gbp, 8);
713
    }
714

    
715
    return 0;
716
}
717

    
718
/** Data table used for TrueHD noise generation function. */
719

    
720
static const int8_t noise_table[256] = {
721
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
722
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
723
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
724
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
725
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
726
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
727
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
728
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
729
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
730
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
731
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
732
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
733
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
734
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
735
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
736
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
737
};
738

    
739
/** Noise generation functions.
740
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
741
 *  sequence generators, used to generate noise data which is used when the
742
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
743
 *  to compression, or just obfuscate the decoder. Are they for some kind of
744
 *  dithering? */
745

    
746
/** Generate two channels of noise, used in the matrix when
747
 *  restart sync word == 0x31ea. */
748

    
749
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
750
{
751
    SubStream *s = &m->substream[substr];
752
    unsigned int i;
753
    uint32_t seed = s->noisegen_seed;
754
    unsigned int maxchan = s->max_matrix_channel;
755

    
756
    for (i = 0; i < s->blockpos; i++) {
757
        uint16_t seed_shr7 = seed >> 7;
758
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
759
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
760

    
761
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
762
    }
763

    
764
    s->noisegen_seed = seed;
765
}
766

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

    
769
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
770
{
771
    SubStream *s = &m->substream[substr];
772
    unsigned int i;
773
    uint32_t seed = s->noisegen_seed;
774

    
775
    for (i = 0; i < m->access_unit_size_pow2; i++) {
776
        uint8_t seed_shr15 = seed >> 15;
777
        m->noise_buffer[i] = noise_table[seed_shr15];
778
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
779
    }
780

    
781
    s->noisegen_seed = seed;
782
}
783

    
784

    
785
/** Apply the channel matrices in turn to reconstruct the original audio
786
 *  samples. */
787

    
788
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
789
{
790
    SubStream *s = &m->substream[substr];
791
    unsigned int mat, src_ch, i;
792
    unsigned int maxchan;
793

    
794
    maxchan = s->max_matrix_channel;
795
    if (!s->noise_type) {
796
        generate_2_noise_channels(m, substr);
797
        maxchan += 2;
798
    } else {
799
        fill_noise_buffer(m, substr);
800
    }
801

    
802
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
803
        int matrix_noise_shift = s->matrix_noise_shift[mat];
804
        unsigned int dest_ch = s->matrix_out_ch[mat];
805
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
806

    
807
        /* TODO: DSPContext? */
808

    
809
        for (i = 0; i < s->blockpos; i++) {
810
            int64_t accum = 0;
811
            for (src_ch = 0; src_ch <= maxchan; src_ch++) {
812
                accum += (int64_t)m->sample_buffer[i][src_ch]
813
                                  * s->matrix_coeff[mat][src_ch];
814
            }
815
            if (matrix_noise_shift) {
816
                uint32_t index = s->num_primitive_matrices - mat;
817
                index = (i * (index * 2 + 1) + index) & (m->access_unit_size_pow2 - 1);
818
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
819
            }
820
            m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
821
                                             + m->bypassed_lsbs[i][mat];
822
        }
823
    }
824
}
825

    
826
/** Write the audio data into the output buffer. */
827

    
828
static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
829
                                uint8_t *data, unsigned int *data_size, int is32)
830
{
831
    SubStream *s = &m->substream[substr];
832
    unsigned int i, ch = 0;
833
    int32_t *data_32 = (int32_t*) data;
834
    int16_t *data_16 = (int16_t*) data;
835

    
836
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
837
        return -1;
838

    
839
    for (i = 0; i < s->blockpos; i++) {
840
        for (ch = 0; ch <= s->max_channel; ch++) {
841
            int32_t sample = m->sample_buffer[i][ch] << s->output_shift[ch];
842
            s->lossless_check_data ^= (sample & 0xffffff) << ch;
843
            if (is32) *data_32++ = sample << 8;
844
            else      *data_16++ = sample >> 8;
845
        }
846
    }
847

    
848
    *data_size = i * ch * (is32 ? 4 : 2);
849

    
850
    return 0;
851
}
852

    
853
static int output_data(MLPDecodeContext *m, unsigned int substr,
854
                       uint8_t *data, unsigned int *data_size)
855
{
856
    if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
857
        return output_data_internal(m, substr, data, data_size, 1);
858
    else
859
        return output_data_internal(m, substr, data, data_size, 0);
860
}
861

    
862

    
863
/** Read an access unit from the stream.
864
 *  Returns < 0 on error, 0 if not enough data is present in the input stream
865
 *  otherwise returns the number of bytes consumed. */
866

    
867
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
868
                            const uint8_t *buf, int buf_size)
869
{
870
    MLPDecodeContext *m = avctx->priv_data;
871
    GetBitContext gb;
872
    unsigned int length, substr;
873
    unsigned int substream_start;
874
    unsigned int header_size = 4;
875
    unsigned int substr_header_size = 0;
876
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
877
    uint16_t substream_data_len[MAX_SUBSTREAMS];
878
    uint8_t parity_bits;
879

    
880
    if (buf_size < 4)
881
        return 0;
882

    
883
    length = (AV_RB16(buf) & 0xfff) * 2;
884

    
885
    if (length > buf_size)
886
        return -1;
887

    
888
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
889

    
890
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
891
        dprintf(m->avctx, "Found major sync.\n");
892
        if (read_major_sync(m, &gb) < 0)
893
            goto error;
894
        header_size += 28;
895
    }
896

    
897
    if (!m->params_valid) {
898
        av_log(m->avctx, AV_LOG_WARNING,
899
               "Stream parameters not seen; skipping frame.\n");
900
        *data_size = 0;
901
        return length;
902
    }
903

    
904
    substream_start = 0;
905

    
906
    for (substr = 0; substr < m->num_substreams; substr++) {
907
        int extraword_present, checkdata_present, end;
908

    
909
        extraword_present = get_bits1(&gb);
910
        skip_bits1(&gb);
911
        checkdata_present = get_bits1(&gb);
912
        skip_bits1(&gb);
913

    
914
        end = get_bits(&gb, 12) * 2;
915

    
916
        substr_header_size += 2;
917

    
918
        if (extraword_present) {
919
            skip_bits(&gb, 16);
920
            substr_header_size += 2;
921
        }
922

    
923
        if (end + header_size + substr_header_size > length) {
924
            av_log(m->avctx, AV_LOG_ERROR,
925
                   "Indicated length of substream %d data goes off end of "
926
                   "packet.\n", substr);
927
            end = length - header_size - substr_header_size;
928
        }
929

    
930
        if (end < substream_start) {
931
            av_log(avctx, AV_LOG_ERROR,
932
                   "Indicated end offset of substream %d data "
933
                   "is smaller than calculated start offset.\n",
934
                   substr);
935
            goto error;
936
        }
937

    
938
        if (substr > m->max_decoded_substream)
939
            continue;
940

    
941
        substream_parity_present[substr] = checkdata_present;
942
        substream_data_len[substr] = end - substream_start;
943
        substream_start = end;
944
    }
945

    
946
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
947
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
948

    
949
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
950
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
951
        goto error;
952
    }
953

    
954
    buf += header_size + substr_header_size;
955

    
956
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
957
        SubStream *s = &m->substream[substr];
958
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
959

    
960
        s->blockpos = 0;
961
        do {
962
            if (get_bits1(&gb)) {
963
                if (get_bits1(&gb)) {
964
                    /* A restart header should be present. */
965
                    if (read_restart_header(m, &gb, buf, substr) < 0)
966
                        goto next_substr;
967
                    s->restart_seen = 1;
968
                }
969

    
970
                if (!s->restart_seen) {
971
                    av_log(m->avctx, AV_LOG_ERROR,
972
                           "No restart header present in substream %d.\n",
973
                           substr);
974
                    goto next_substr;
975
                }
976

    
977
                if (read_decoding_params(m, &gb, substr) < 0)
978
                    goto next_substr;
979
            }
980

    
981
            if (!s->restart_seen) {
982
                av_log(m->avctx, AV_LOG_ERROR,
983
                       "No restart header present in substream %d.\n",
984
                       substr);
985
                goto next_substr;
986
            }
987

    
988
            if (read_block_data(m, &gb, substr) < 0)
989
                return -1;
990

    
991
        } while ((get_bits_count(&gb) < substream_data_len[substr] * 8)
992
                 && get_bits1(&gb) == 0);
993

    
994
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
995
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32 &&
996
            (show_bits_long(&gb, 32) == 0xd234d234 ||
997
             show_bits_long(&gb, 20) == 0xd234e)) {
998
            skip_bits(&gb, 18);
999
            if (substr == m->max_decoded_substream)
1000
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1001

    
1002
            if (get_bits1(&gb)) {
1003
                int shorten_by = get_bits(&gb, 13);
1004
                shorten_by = FFMIN(shorten_by, s->blockpos);
1005
                s->blockpos -= shorten_by;
1006
            } else
1007
                skip_bits(&gb, 13);
1008
        }
1009
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 16 &&
1010
            substream_parity_present[substr]) {
1011
            uint8_t parity, checksum;
1012

    
1013
            parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1014
            if ((parity ^ get_bits(&gb, 8)) != 0xa9)
1015
                av_log(m->avctx, AV_LOG_ERROR,
1016
                       "Substream %d parity check failed.\n", substr);
1017

    
1018
            checksum = ff_mlp_checksum8(buf, substream_data_len[substr] - 2);
1019
            if (checksum != get_bits(&gb, 8))
1020
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n",
1021
                       substr);
1022
        }
1023
        if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
1024
            av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n",
1025
                   substr);
1026
            return -1;
1027
        }
1028

    
1029
next_substr:
1030
        buf += substream_data_len[substr];
1031
    }
1032

    
1033
    rematrix_channels(m, m->max_decoded_substream);
1034

    
1035
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1036
        return -1;
1037

    
1038
    return length;
1039

    
1040
error:
1041
    m->params_valid = 0;
1042
    return -1;
1043
}
1044

    
1045
AVCodec mlp_decoder = {
1046
    "mlp",
1047
    CODEC_TYPE_AUDIO,
1048
    CODEC_ID_MLP,
1049
    sizeof(MLPDecodeContext),
1050
    mlp_decode_init,
1051
    NULL,
1052
    NULL,
1053
    read_access_unit,
1054
    .long_name = NULL_IF_CONFIG_SMALL("Meridian Lossless Packing"),
1055
};
1056