Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ 72415b2a

History | View | Annotate | Download (38.1 KB)

1 b517af05 Ramiro Polla
/*
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 bad5537e Diego Biurrun
 * @file libavcodec/mlpdec.c
24 b517af05 Ramiro Polla
 * MLP decoder
25
 */
26
27 0e74e1ff Diego Biurrun
#include <stdint.h>
28
29 b517af05 Ramiro Polla
#include "avcodec.h"
30 bf4f19dc Ramiro Polla
#include "dsputil.h"
31 b517af05 Ramiro Polla
#include "libavutil/intreadwrite.h"
32 9106a698 Stefano Sabatini
#include "get_bits.h"
33 b517af05 Ramiro Polla
#include "libavutil/crc.h"
34
#include "parser.h"
35
#include "mlp_parser.h"
36 ce15710f Ramiro Polla
#include "mlp.h"
37 b517af05 Ramiro Polla
38 9906a2be Diego Biurrun
/** number of bits used for VLC lookup - longest Huffman code is 9 */
39 b517af05 Ramiro Polla
#define VLC_BITS            9
40
41
42
static const char* sample_message =
43
    "Please file a bug report following the instructions at "
44 0fa5f24c Diego Biurrun
    "http://ffmpeg.org/bugreports.html and include "
45 b517af05 Ramiro Polla
    "a sample of this file.";
46
47
typedef struct SubStream {
48 9906a2be Diego Biurrun
    //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
49 b517af05 Ramiro Polla
    uint8_t     restart_seen;
50
51
    //@{
52
    /** restart header data */
53
    //! The type of noise to be used in the rematrix stage.
54
    uint16_t    noise_type;
55
56
    //! The index of the first channel coded in this substream.
57
    uint8_t     min_channel;
58
    //! The index of the last channel coded in this substream.
59
    uint8_t     max_channel;
60
    //! The number of channels input into the rematrix stage.
61
    uint8_t     max_matrix_channel;
62 9731e7f1 Ramiro Polla
    //! For each channel output by the matrix, the output channel to map it to
63
    uint8_t     ch_assign[MAX_CHANNELS];
64 b517af05 Ramiro Polla
65
    //! The left shift applied to random noise in 0x31ea substreams.
66
    uint8_t     noise_shift;
67
    //! The current seed value for the pseudorandom noise generator(s).
68
    uint32_t    noisegen_seed;
69
70
    //! Set if the substream contains extra info to check the size of VLC blocks.
71
    uint8_t     data_check_present;
72
73
    //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
74
    uint8_t     param_presence_flags;
75
#define PARAM_BLOCKSIZE     (1 << 7)
76
#define PARAM_MATRIX        (1 << 6)
77
#define PARAM_OUTSHIFT      (1 << 5)
78
#define PARAM_QUANTSTEP     (1 << 4)
79
#define PARAM_FIR           (1 << 3)
80
#define PARAM_IIR           (1 << 2)
81
#define PARAM_HUFFOFFSET    (1 << 1)
82 cbf3cf19 Ramiro Polla
#define PARAM_PRESENCE      (1 << 0)
83 b517af05 Ramiro Polla
    //@}
84
85
    //@{
86
    /** matrix data */
87
88
    //! Number of matrices to be applied.
89
    uint8_t     num_primitive_matrices;
90
91
    //! matrix output channel
92
    uint8_t     matrix_out_ch[MAX_MATRICES];
93
94
    //! Whether the LSBs of the matrix output are encoded in the bitstream.
95
    uint8_t     lsb_bypass[MAX_MATRICES];
96
    //! Matrix coefficients, stored as 2.14 fixed point.
97 420df930 Ramiro Polla
    int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
98 b517af05 Ramiro Polla
    //! Left shift to apply to noise values in 0x31eb substreams.
99
    uint8_t     matrix_noise_shift[MAX_MATRICES];
100
    //@}
101
102 9906a2be Diego Biurrun
    //! Left shift to apply to Huffman-decoded residuals.
103 b517af05 Ramiro Polla
    uint8_t     quant_step_size[MAX_CHANNELS];
104
105 9906a2be Diego Biurrun
    //! number of PCM samples in current audio block
106 b517af05 Ramiro Polla
    uint16_t    blocksize;
107
    //! Number of PCM samples decoded so far in this frame.
108
    uint16_t    blockpos;
109
110
    //! Left shift to apply to decoded PCM values to get final 24-bit output.
111
    int8_t      output_shift[MAX_CHANNELS];
112
113
    //! Running XOR of all output samples.
114
    int32_t     lossless_check_data;
115
116
} SubStream;
117
118
typedef struct MLPDecodeContext {
119
    AVCodecContext *avctx;
120
121 cc9c5126 Ramiro Polla
    //! Current access unit being read has a major sync.
122
    int         is_major_sync_unit;
123
124 b517af05 Ramiro Polla
    //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
125
    uint8_t     params_valid;
126
127
    //! Number of substreams contained within this stream.
128
    uint8_t     num_substreams;
129
130
    //! Index of the last substream to decode - further substreams are skipped.
131
    uint8_t     max_decoded_substream;
132
133 9906a2be Diego Biurrun
    //! number of PCM samples contained in each frame
134 b517af05 Ramiro Polla
    int         access_unit_size;
135 9906a2be Diego Biurrun
    //! next power of two above the number of samples in each frame
136 b517af05 Ramiro Polla
    int         access_unit_size_pow2;
137
138
    SubStream   substream[MAX_SUBSTREAMS];
139
140 f53acb7b Ramiro Polla
    ChannelParams channel_params[MAX_CHANNELS];
141 b517af05 Ramiro Polla
142 75428fa4 Ramiro Polla
    int         matrix_changed;
143
    int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
144
145 b517af05 Ramiro Polla
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
146
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
147 420df930 Ramiro Polla
    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
148 bf4f19dc Ramiro Polla
149
    DSPContext  dsp;
150 b517af05 Ramiro Polla
} MLPDecodeContext;
151
152
static VLC huff_vlc[3];
153
154
/** Initialize static data, constant between all invocations of the codec. */
155
156 dc8a7c93 Diego Biurrun
static av_cold void init_static(void)
157 b517af05 Ramiro Polla
{
158 7fd88069 Ramiro Polla
    if (!huff_vlc[0].bits) {
159 52ae1e86 Ramiro Polla
        INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
160
                    &ff_mlp_huffman_tables[0][0][1], 2, 1,
161
                    &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
162
        INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
163
                    &ff_mlp_huffman_tables[1][0][1], 2, 1,
164
                    &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
165
        INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
166
                    &ff_mlp_huffman_tables[2][0][1], 2, 1,
167
                    &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
168 7fd88069 Ramiro Polla
    }
169 b517af05 Ramiro Polla
170 ce15710f Ramiro Polla
    ff_mlp_init_crc();
171 b517af05 Ramiro Polla
}
172
173
static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
174
                                          unsigned int substr, unsigned int ch)
175
{
176 f53acb7b Ramiro Polla
    ChannelParams *cp = &m->channel_params[ch];
177 b517af05 Ramiro Polla
    SubStream *s = &m->substream[substr];
178 f53acb7b Ramiro Polla
    int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
179
    int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
180
    int32_t sign_huff_offset = cp->huff_offset;
181 b517af05 Ramiro Polla
182 f53acb7b Ramiro Polla
    if (cp->codebook > 0)
183 b517af05 Ramiro Polla
        sign_huff_offset -= 7 << lsb_bits;
184
185
    if (sign_shift >= 0)
186
        sign_huff_offset -= 1 << sign_shift;
187
188
    return sign_huff_offset;
189
}
190
191
/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
192
 *  and plain LSBs. */
193
194
static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
195
                                     unsigned int substr, unsigned int pos)
196
{
197
    SubStream *s = &m->substream[substr];
198
    unsigned int mat, channel;
199
200
    for (mat = 0; mat < s->num_primitive_matrices; mat++)
201
        if (s->lsb_bypass[mat])
202
            m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
203
204
    for (channel = s->min_channel; channel <= s->max_channel; channel++) {
205 f53acb7b Ramiro Polla
        ChannelParams *cp = &m->channel_params[channel];
206
        int codebook = cp->codebook;
207 b517af05 Ramiro Polla
        int quant_step_size = s->quant_step_size[channel];
208 f53acb7b Ramiro Polla
        int lsb_bits = cp->huff_lsbs - quant_step_size;
209 b517af05 Ramiro Polla
        int result = 0;
210
211
        if (codebook > 0)
212
            result = get_vlc2(gbp, huff_vlc[codebook-1].table,
213
                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
214
215
        if (result < 0)
216
            return -1;
217
218
        if (lsb_bits > 0)
219
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
220
221 f53acb7b Ramiro Polla
        result  += cp->sign_huff_offset;
222 b517af05 Ramiro Polla
        result <<= quant_step_size;
223
224
        m->sample_buffer[pos + s->blockpos][channel] = result;
225
    }
226
227
    return 0;
228
}
229
230
static av_cold int mlp_decode_init(AVCodecContext *avctx)
231
{
232
    MLPDecodeContext *m = avctx->priv_data;
233
    int substr;
234
235
    init_static();
236
    m->avctx = avctx;
237
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
238
        m->substream[substr].lossless_check_data = 0xffffffff;
239 bf4f19dc Ramiro Polla
    dsputil_init(&m->dsp, avctx);
240 ee1a8f62 Ramiro Polla
241 b517af05 Ramiro Polla
    return 0;
242
}
243
244
/** Read a major sync info header - contains high level information about
245
 *  the stream - sample rate, channel arrangement etc. Most of this
246
 *  information is not actually necessary for decoding, only for playback.
247
 */
248
249
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
250
{
251
    MLPHeaderInfo mh;
252
    int substr;
253
254
    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
255
        return -1;
256
257
    if (mh.group1_bits == 0) {
258 9906a2be Diego Biurrun
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
259 b517af05 Ramiro Polla
        return -1;
260
    }
261
    if (mh.group2_bits > mh.group1_bits) {
262
        av_log(m->avctx, AV_LOG_ERROR,
263 9906a2be Diego Biurrun
               "Channel group 2 cannot have more bits per sample than group 1.\n");
264 b517af05 Ramiro Polla
        return -1;
265
    }
266
267
    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
268
        av_log(m->avctx, AV_LOG_ERROR,
269 9906a2be Diego Biurrun
               "Channel groups with differing sample rates are not currently supported.\n");
270 b517af05 Ramiro Polla
        return -1;
271
    }
272
273
    if (mh.group1_samplerate == 0) {
274 9906a2be Diego Biurrun
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
275 b517af05 Ramiro Polla
        return -1;
276
    }
277
    if (mh.group1_samplerate > MAX_SAMPLERATE) {
278
        av_log(m->avctx, AV_LOG_ERROR,
279 9906a2be Diego Biurrun
               "Sampling rate %d is greater than the supported maximum (%d).\n",
280 b517af05 Ramiro Polla
               mh.group1_samplerate, MAX_SAMPLERATE);
281
        return -1;
282
    }
283
    if (mh.access_unit_size > MAX_BLOCKSIZE) {
284
        av_log(m->avctx, AV_LOG_ERROR,
285 9906a2be Diego Biurrun
               "Block size %d is greater than the supported maximum (%d).\n",
286 b517af05 Ramiro Polla
               mh.access_unit_size, MAX_BLOCKSIZE);
287
        return -1;
288
    }
289
    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
290
        av_log(m->avctx, AV_LOG_ERROR,
291 9906a2be Diego Biurrun
               "Block size pow2 %d is greater than the supported maximum (%d).\n",
292 b517af05 Ramiro Polla
               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
293
        return -1;
294
    }
295
296
    if (mh.num_substreams == 0)
297
        return -1;
298 932cee5d Ramiro Polla
    if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
299
        av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
300
        return -1;
301
    }
302 b517af05 Ramiro Polla
    if (mh.num_substreams > MAX_SUBSTREAMS) {
303
        av_log(m->avctx, AV_LOG_ERROR,
304 9906a2be Diego Biurrun
               "Number of substreams %d is larger than the maximum supported "
305
               "by the decoder. %s\n", mh.num_substreams, sample_message);
306 b517af05 Ramiro Polla
        return -1;
307
    }
308
309
    m->access_unit_size      = mh.access_unit_size;
310
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;
311
312
    m->num_substreams        = mh.num_substreams;
313
    m->max_decoded_substream = m->num_substreams - 1;
314
315
    m->avctx->sample_rate    = mh.group1_samplerate;
316
    m->avctx->frame_size     = mh.access_unit_size;
317
318 97679e6e Mathieu Velten
    m->avctx->bits_per_raw_sample = mh.group1_bits;
319 c687643c Ramiro Polla
    if (mh.group1_bits > 16)
320 b517af05 Ramiro Polla
        m->avctx->sample_fmt = SAMPLE_FMT_S32;
321 ee1a8f62 Ramiro Polla
    else
322
        m->avctx->sample_fmt = SAMPLE_FMT_S16;
323 b517af05 Ramiro Polla
324
    m->params_valid = 1;
325
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
326
        m->substream[substr].restart_seen = 0;
327
328
    return 0;
329
}
330
331
/** Read a restart header from a block in a substream. This contains parameters
332
 *  required to decode the audio that do not change very often. Generally
333
 *  (always) present only in blocks following a major sync. */
334
335
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
336
                               const uint8_t *buf, unsigned int substr)
337
{
338
    SubStream *s = &m->substream[substr];
339
    unsigned int ch;
340
    int sync_word, tmp;
341
    uint8_t checksum;
342
    uint8_t lossless_check;
343
    int start_count = get_bits_count(gbp);
344 868170c4 Ramiro Polla
    const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
345
                                 ? MAX_MATRIX_CHANNEL_MLP
346
                                 : MAX_MATRIX_CHANNEL_TRUEHD;
347 b517af05 Ramiro Polla
348
    sync_word = get_bits(gbp, 13);
349
350 e8d341ce Ramiro Polla
    if (sync_word != 0x31ea >> 1) {
351 b517af05 Ramiro Polla
        av_log(m->avctx, AV_LOG_ERROR,
352 9906a2be Diego Biurrun
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
353 b517af05 Ramiro Polla
        return -1;
354
    }
355
356 e8d341ce Ramiro Polla
    s->noise_type = get_bits1(gbp);
357
358
    if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
359
        av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
360
        return -1;
361
    }
362
363 b517af05 Ramiro Polla
    skip_bits(gbp, 16); /* Output timestamp */
364
365
    s->min_channel        = get_bits(gbp, 4);
366
    s->max_channel        = get_bits(gbp, 4);
367
    s->max_matrix_channel = get_bits(gbp, 4);
368
369 868170c4 Ramiro Polla
    if (s->max_matrix_channel > max_matrix_channel) {
370
        av_log(m->avctx, AV_LOG_ERROR,
371
               "Max matrix channel cannot be greater than %d.\n",
372
               max_matrix_channel);
373
        return -1;
374
    }
375
376
    if (s->max_channel != s->max_matrix_channel) {
377
        av_log(m->avctx, AV_LOG_ERROR,
378
               "Max channel must be equal max matrix channel.\n");
379
        return -1;
380
    }
381
382 e2822726 Ramiro Polla
    /* This should happen for TrueHD streams with >6 channels and MLP's noise
383
     * type. It is not yet known if this is allowed. */
384
    if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
385
        av_log(m->avctx, AV_LOG_ERROR,
386
               "Number of channels %d is larger than the maximum supported "
387
               "by the decoder. %s\n", s->max_channel+2, sample_message);
388
        return -1;
389
    }
390
391 b517af05 Ramiro Polla
    if (s->min_channel > s->max_channel) {
392
        av_log(m->avctx, AV_LOG_ERROR,
393
               "Substream min channel cannot be greater than max channel.\n");
394
        return -1;
395
    }
396
397
    if (m->avctx->request_channels > 0
398
        && s->max_channel + 1 >= m->avctx->request_channels
399
        && substr < m->max_decoded_substream) {
400 d780511b Reimar Döffinger
        av_log(m->avctx, AV_LOG_DEBUG,
401 b517af05 Ramiro Polla
               "Extracting %d channel downmix from substream %d. "
402
               "Further substreams will be skipped.\n",
403
               s->max_channel + 1, substr);
404
        m->max_decoded_substream = substr;
405
    }
406
407
    s->noise_shift   = get_bits(gbp,  4);
408
    s->noisegen_seed = get_bits(gbp, 23);
409
410
    skip_bits(gbp, 19);
411
412
    s->data_check_present = get_bits1(gbp);
413
    lossless_check = get_bits(gbp, 8);
414
    if (substr == m->max_decoded_substream
415
        && s->lossless_check_data != 0xffffffff) {
416 a7cc783d Ramiro Polla
        tmp = xor_32_to_8(s->lossless_check_data);
417 b517af05 Ramiro Polla
        if (tmp != lossless_check)
418
            av_log(m->avctx, AV_LOG_WARNING,
419 9906a2be Diego Biurrun
                   "Lossless check failed - expected %02x, calculated %02x.\n",
420 b517af05 Ramiro Polla
                   lossless_check, tmp);
421
    }
422
423
    skip_bits(gbp, 16);
424
425 9731e7f1 Ramiro Polla
    memset(s->ch_assign, 0, sizeof(s->ch_assign));
426
427 b517af05 Ramiro Polla
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
428
        int ch_assign = get_bits(gbp, 6);
429 9731e7f1 Ramiro Polla
        if (ch_assign > s->max_matrix_channel) {
430 b517af05 Ramiro Polla
            av_log(m->avctx, AV_LOG_ERROR,
431 9731e7f1 Ramiro Polla
                   "Assignment of matrix channel %d to invalid output channel %d. %s\n",
432
                   ch, ch_assign, sample_message);
433 b517af05 Ramiro Polla
            return -1;
434
        }
435 9731e7f1 Ramiro Polla
        s->ch_assign[ch_assign] = ch;
436 b517af05 Ramiro Polla
    }
437
438 ce15710f Ramiro Polla
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
439 b517af05 Ramiro Polla
440
    if (checksum != get_bits(gbp, 8))
441 9906a2be Diego Biurrun
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
442 b517af05 Ramiro Polla
443 9906a2be Diego Biurrun
    /* Set default decoding parameters. */
444 b517af05 Ramiro Polla
    s->param_presence_flags   = 0xff;
445
    s->num_primitive_matrices = 0;
446
    s->blocksize              = 8;
447
    s->lossless_check_data    = 0;
448
449
    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
450
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
451
452
    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
453 f53acb7b Ramiro Polla
        ChannelParams *cp = &m->channel_params[ch];
454
        cp->filter_params[FIR].order = 0;
455
        cp->filter_params[IIR].order = 0;
456
        cp->filter_params[FIR].shift = 0;
457
        cp->filter_params[IIR].shift = 0;
458 b517af05 Ramiro Polla
459 9906a2be Diego Biurrun
        /* Default audio coding is 24-bit raw PCM. */
460 f53acb7b Ramiro Polla
        cp->huff_offset      = 0;
461
        cp->sign_huff_offset = (-1) << 23;
462
        cp->codebook         = 0;
463
        cp->huff_lsbs        = 24;
464 b517af05 Ramiro Polla
    }
465
466 f95f6ab9 Ramiro Polla
    if (substr == m->max_decoded_substream)
467 9731e7f1 Ramiro Polla
        m->avctx->channels = s->max_matrix_channel + 1;
468 b517af05 Ramiro Polla
469
    return 0;
470
}
471
472
/** Read parameters for one of the prediction filters. */
473
474
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
475
                              unsigned int channel, unsigned int filter)
476
{
477 f53acb7b Ramiro Polla
    FilterParams *fp = &m->channel_params[channel].filter_params[filter];
478 0c5670a0 Ramiro Polla
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
479 b517af05 Ramiro Polla
    const char fchar = filter ? 'I' : 'F';
480
    int i, order;
481
482 9906a2be Diego Biurrun
    // Filter is 0 for FIR, 1 for IIR.
483 b517af05 Ramiro Polla
    assert(filter < 2);
484
485 5d9e4eaa Ramiro Polla
    if (m->filter_changed[channel][filter]++ > 1) {
486
        av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
487
        return -1;
488
    }
489 75428fa4 Ramiro Polla
490 b517af05 Ramiro Polla
    order = get_bits(gbp, 4);
491 0c5670a0 Ramiro Polla
    if (order > max_order) {
492 b517af05 Ramiro Polla
        av_log(m->avctx, AV_LOG_ERROR,
493 9906a2be Diego Biurrun
               "%cIR filter order %d is greater than maximum %d.\n",
494 0c5670a0 Ramiro Polla
               fchar, order, max_order);
495 b517af05 Ramiro Polla
        return -1;
496
    }
497 d6aa052d Ramiro Polla
    fp->order = order;
498 b517af05 Ramiro Polla
499
    if (order > 0) {
500 13bd2044 Ramiro Polla
        int32_t *fcoeff = m->channel_params[channel].coeff[filter];
501 b517af05 Ramiro Polla
        int coeff_bits, coeff_shift;
502
503 d6aa052d Ramiro Polla
        fp->shift = get_bits(gbp, 4);
504 b517af05 Ramiro Polla
505
        coeff_bits  = get_bits(gbp, 5);
506
        coeff_shift = get_bits(gbp, 3);
507
        if (coeff_bits < 1 || coeff_bits > 16) {
508
            av_log(m->avctx, AV_LOG_ERROR,
509 9906a2be Diego Biurrun
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
510 b517af05 Ramiro Polla
                   fchar);
511
            return -1;
512
        }
513
        if (coeff_bits + coeff_shift > 16) {
514
            av_log(m->avctx, AV_LOG_ERROR,
515 9906a2be Diego Biurrun
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
516 b517af05 Ramiro Polla
                   fchar);
517
            return -1;
518
        }
519
520
        for (i = 0; i < order; i++)
521 13bd2044 Ramiro Polla
            fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
522 b517af05 Ramiro Polla
523
        if (get_bits1(gbp)) {
524
            int state_bits, state_shift;
525
526
            if (filter == FIR) {
527
                av_log(m->avctx, AV_LOG_ERROR,
528 9906a2be Diego Biurrun
                       "FIR filter has state data specified.\n");
529 b517af05 Ramiro Polla
                return -1;
530
            }
531
532
            state_bits  = get_bits(gbp, 4);
533
            state_shift = get_bits(gbp, 4);
534
535 9906a2be Diego Biurrun
            /* TODO: Check validity of state data. */
536 b517af05 Ramiro Polla
537
            for (i = 0; i < order; i++)
538 db01fa13 Ramiro Polla
                fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
539 b517af05 Ramiro Polla
        }
540
    }
541
542
    return 0;
543
}
544
545 f8e6293b Ramiro Polla
/** Read parameters for primitive matrices. */
546
547 95c14b1e Ramiro Polla
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
548 f8e6293b Ramiro Polla
{
549 95c14b1e Ramiro Polla
    SubStream *s = &m->substream[substr];
550 f8e6293b Ramiro Polla
    unsigned int mat, ch;
551 309616b2 Ramiro Polla
    const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
552
                                     ? MAX_MATRICES_MLP
553
                                     : MAX_MATRICES_TRUEHD;
554 f8e6293b Ramiro Polla
555 5d9e4eaa Ramiro Polla
    if (m->matrix_changed++ > 1) {
556
        av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
557
        return -1;
558
    }
559
560 f8e6293b Ramiro Polla
    s->num_primitive_matrices = get_bits(gbp, 4);
561
562 309616b2 Ramiro Polla
    if (s->num_primitive_matrices > max_primitive_matrices) {
563
        av_log(m->avctx, AV_LOG_ERROR,
564
               "Number of primitive matrices cannot be greater than %d.\n",
565
               max_primitive_matrices);
566
        return -1;
567
    }
568
569 f8e6293b Ramiro Polla
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
570
        int frac_bits, max_chan;
571
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
572
        frac_bits             = get_bits(gbp, 4);
573
        s->lsb_bypass   [mat] = get_bits1(gbp);
574
575 0091d8a1 Ramiro Polla
        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
576 f8e6293b Ramiro Polla
            av_log(m->avctx, AV_LOG_ERROR,
577
                    "Invalid channel %d specified as output from matrix.\n",
578
                    s->matrix_out_ch[mat]);
579
            return -1;
580
        }
581
        if (frac_bits > 14) {
582
            av_log(m->avctx, AV_LOG_ERROR,
583
                    "Too many fractional bits specified.\n");
584
            return -1;
585
        }
586
587
        max_chan = s->max_matrix_channel;
588
        if (!s->noise_type)
589
            max_chan+=2;
590
591
        for (ch = 0; ch <= max_chan; ch++) {
592
            int coeff_val = 0;
593
            if (get_bits1(gbp))
594
                coeff_val = get_sbits(gbp, frac_bits + 2);
595
596
            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
597
        }
598
599
        if (s->noise_type)
600
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
601
        else
602
            s->matrix_noise_shift[mat] = 0;
603
    }
604
605
    return 0;
606
}
607
608 43ee5fe0 Ramiro Polla
/** Read channel parameters. */
609
610
static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
611
                               GetBitContext *gbp, unsigned int ch)
612
{
613
    ChannelParams *cp = &m->channel_params[ch];
614
    FilterParams *fir = &cp->filter_params[FIR];
615
    FilterParams *iir = &cp->filter_params[IIR];
616
    SubStream *s = &m->substream[substr];
617
618
    if (s->param_presence_flags & PARAM_FIR)
619
        if (get_bits1(gbp))
620
            if (read_filter_params(m, gbp, ch, FIR) < 0)
621
                return -1;
622
623
    if (s->param_presence_flags & PARAM_IIR)
624
        if (get_bits1(gbp))
625
            if (read_filter_params(m, gbp, ch, IIR) < 0)
626
                return -1;
627
628 125cf771 Ramiro Polla
    if (fir->order + iir->order > 8) {
629
        av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
630
        return -1;
631
    }
632
633 43ee5fe0 Ramiro Polla
    if (fir->order && iir->order &&
634
        fir->shift != iir->shift) {
635
        av_log(m->avctx, AV_LOG_ERROR,
636
                "FIR and IIR filters must use the same precision.\n");
637
        return -1;
638
    }
639
    /* The FIR and IIR filters must have the same precision.
640 aff42ee0 Ramiro Polla
     * To simplify the filtering code, only the precision of the
641
     * FIR filter is considered. If only the IIR filter is employed,
642
     * the FIR filter precision is set to that of the IIR filter, so
643
     * that the filtering code can use it. */
644 43ee5fe0 Ramiro Polla
    if (!fir->order && iir->order)
645
        fir->shift = iir->shift;
646
647
    if (s->param_presence_flags & PARAM_HUFFOFFSET)
648
        if (get_bits1(gbp))
649
            cp->huff_offset = get_sbits(gbp, 15);
650
651
    cp->codebook  = get_bits(gbp, 2);
652
    cp->huff_lsbs = get_bits(gbp, 5);
653
654 125cf771 Ramiro Polla
    if (cp->huff_lsbs > 24) {
655
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
656
        return -1;
657
    }
658 43ee5fe0 Ramiro Polla
659 125cf771 Ramiro Polla
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
660 43ee5fe0 Ramiro Polla
661
    return 0;
662
}
663
664 b517af05 Ramiro Polla
/** Read decoding parameters that change more often than those in the restart
665
 *  header. */
666
667
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
668
                                unsigned int substr)
669
{
670
    SubStream *s = &m->substream[substr];
671 f8e6293b Ramiro Polla
    unsigned int ch;
672 b517af05 Ramiro Polla
673 cbf3cf19 Ramiro Polla
    if (s->param_presence_flags & PARAM_PRESENCE)
674 f95f6ab9 Ramiro Polla
        if (get_bits1(gbp))
675
            s->param_presence_flags = get_bits(gbp, 8);
676 b517af05 Ramiro Polla
677
    if (s->param_presence_flags & PARAM_BLOCKSIZE)
678
        if (get_bits1(gbp)) {
679
            s->blocksize = get_bits(gbp, 9);
680 b864098c Ramiro Polla
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
681
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
682 b517af05 Ramiro Polla
                s->blocksize = 0;
683
                return -1;
684
            }
685
        }
686
687
    if (s->param_presence_flags & PARAM_MATRIX)
688 f95f6ab9 Ramiro Polla
        if (get_bits1(gbp))
689 95c14b1e Ramiro Polla
            if (read_matrix_params(m, substr, gbp) < 0)
690 f8e6293b Ramiro Polla
                return -1;
691 b517af05 Ramiro Polla
692
    if (s->param_presence_flags & PARAM_OUTSHIFT)
693
        if (get_bits1(gbp))
694 f95f6ab9 Ramiro Polla
            for (ch = 0; ch <= s->max_matrix_channel; ch++)
695 af048026 Ramiro Polla
                s->output_shift[ch] = get_sbits(gbp, 4);
696 b517af05 Ramiro Polla
697
    if (s->param_presence_flags & PARAM_QUANTSTEP)
698
        if (get_bits1(gbp))
699
            for (ch = 0; ch <= s->max_channel; ch++) {
700 f53acb7b Ramiro Polla
                ChannelParams *cp = &m->channel_params[ch];
701
702 b517af05 Ramiro Polla
                s->quant_step_size[ch] = get_bits(gbp, 4);
703
704 f53acb7b Ramiro Polla
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
705 b517af05 Ramiro Polla
            }
706
707
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
708 f95f6ab9 Ramiro Polla
        if (get_bits1(gbp))
709 43ee5fe0 Ramiro Polla
            if (read_channel_params(m, substr, gbp, ch) < 0)
710 b517af05 Ramiro Polla
                return -1;
711
712
    return 0;
713
}
714
715
#define MSB_MASK(bits)  (-1u << bits)
716
717
/** Generate PCM samples using the prediction filters and residual values
718
 *  read from the data stream, and update the filter state. */
719
720
static void filter_channel(MLPDecodeContext *m, unsigned int substr,
721
                           unsigned int channel)
722
{
723
    SubStream *s = &m->substream[substr];
724 13bd2044 Ramiro Polla
    const int32_t *fircoeff = m->channel_params[channel].coeff[FIR];
725
    int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
726
    int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
727
    int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
728 e71365f4 Ramiro Polla
    FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
729
    FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
730
    unsigned int filter_shift = fir->shift;
731 b517af05 Ramiro Polla
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);
732
733 77b12f80 Ramiro Polla
    memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
734
    memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
735 b517af05 Ramiro Polla
736 13bd2044 Ramiro Polla
    m->dsp.mlp_filter_channel(firbuf, fircoeff,
737
                              fir->order, iir->order,
738 bf4f19dc Ramiro Polla
                              filter_shift, mask, s->blocksize,
739
                              &m->sample_buffer[s->blockpos][channel]);
740 b517af05 Ramiro Polla
741 bf4f19dc Ramiro Polla
    memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
742
    memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
743 b517af05 Ramiro Polla
}
744
745
/** Read a block of PCM residual data (or actual if no filtering active). */
746
747
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
748
                           unsigned int substr)
749
{
750
    SubStream *s = &m->substream[substr];
751
    unsigned int i, ch, expected_stream_pos = 0;
752
753
    if (s->data_check_present) {
754
        expected_stream_pos  = get_bits_count(gbp);
755
        expected_stream_pos += get_bits(gbp, 16);
756
        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
757
               "we have not tested yet. %s\n", sample_message);
758
    }
759
760
    if (s->blockpos + s->blocksize > m->access_unit_size) {
761 9906a2be Diego Biurrun
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
762 b517af05 Ramiro Polla
        return -1;
763
    }
764
765
    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
766
           s->blocksize * sizeof(m->bypassed_lsbs[0]));
767
768 f95f6ab9 Ramiro Polla
    for (i = 0; i < s->blocksize; i++)
769 b517af05 Ramiro Polla
        if (read_huff_channels(m, gbp, substr, i) < 0)
770
            return -1;
771
772 f95f6ab9 Ramiro Polla
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
773 b517af05 Ramiro Polla
        filter_channel(m, substr, ch);
774
775
    s->blockpos += s->blocksize;
776
777
    if (s->data_check_present) {
778
        if (get_bits_count(gbp) != expected_stream_pos)
779 9906a2be Diego Biurrun
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
780 b517af05 Ramiro Polla
        skip_bits(gbp, 8);
781
    }
782
783
    return 0;
784
}
785
786 9906a2be Diego Biurrun
/** Data table used for TrueHD noise generation function. */
787 b517af05 Ramiro Polla
788
static const int8_t noise_table[256] = {
789
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
790
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
791
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
792
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
793
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
794
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
795
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
796
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
797
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
798
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
799
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
800
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
801
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
802
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
803
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
804
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
805
};
806
807
/** Noise generation functions.
808
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
809
 *  sequence generators, used to generate noise data which is used when the
810
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
811
 *  to compression, or just obfuscate the decoder. Are they for some kind of
812
 *  dithering? */
813
814
/** Generate two channels of noise, used in the matrix when
815
 *  restart sync word == 0x31ea. */
816
817
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
818
{
819
    SubStream *s = &m->substream[substr];
820
    unsigned int i;
821
    uint32_t seed = s->noisegen_seed;
822
    unsigned int maxchan = s->max_matrix_channel;
823
824
    for (i = 0; i < s->blockpos; i++) {
825
        uint16_t seed_shr7 = seed >> 7;
826
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
827
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
828
829
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
830
    }
831
832
    s->noisegen_seed = seed;
833
}
834
835
/** Generate a block of noise, used when restart sync word == 0x31eb. */
836
837
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
838
{
839
    SubStream *s = &m->substream[substr];
840
    unsigned int i;
841
    uint32_t seed = s->noisegen_seed;
842
843
    for (i = 0; i < m->access_unit_size_pow2; i++) {
844
        uint8_t seed_shr15 = seed >> 15;
845
        m->noise_buffer[i] = noise_table[seed_shr15];
846
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
847
    }
848
849
    s->noisegen_seed = seed;
850
}
851
852
853
/** Apply the channel matrices in turn to reconstruct the original audio
854
 *  samples. */
855
856
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
857
{
858
    SubStream *s = &m->substream[substr];
859
    unsigned int mat, src_ch, i;
860
    unsigned int maxchan;
861
862
    maxchan = s->max_matrix_channel;
863
    if (!s->noise_type) {
864
        generate_2_noise_channels(m, substr);
865
        maxchan += 2;
866
    } else {
867
        fill_noise_buffer(m, substr);
868
    }
869
870
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
871
        int matrix_noise_shift = s->matrix_noise_shift[mat];
872
        unsigned int dest_ch = s->matrix_out_ch[mat];
873
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
874 63ad832d Ramiro Polla
        int32_t *coeffs = s->matrix_coeff[mat];
875 15e6748b Ramiro Polla
        int index  = s->num_primitive_matrices - mat;
876
        int index2 = 2 * index + 1;
877 b517af05 Ramiro Polla
878
        /* TODO: DSPContext? */
879
880
        for (i = 0; i < s->blockpos; i++) {
881 a256445e Ramiro Polla
            int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
882 63ad832d Ramiro Polla
            int32_t *samples = m->sample_buffer[i];
883 b517af05 Ramiro Polla
            int64_t accum = 0;
884 f95f6ab9 Ramiro Polla
885
            for (src_ch = 0; src_ch <= maxchan; src_ch++)
886
                accum += (int64_t) samples[src_ch] * coeffs[src_ch];
887
888 b517af05 Ramiro Polla
            if (matrix_noise_shift) {
889 15e6748b Ramiro Polla
                index &= m->access_unit_size_pow2 - 1;
890 b517af05 Ramiro Polla
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
891 15e6748b Ramiro Polla
                index += index2;
892 b517af05 Ramiro Polla
            }
893 f95f6ab9 Ramiro Polla
894 a256445e Ramiro Polla
            samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
895 b517af05 Ramiro Polla
        }
896
    }
897
}
898
899
/** Write the audio data into the output buffer. */
900
901
static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
902
                                uint8_t *data, unsigned int *data_size, int is32)
903
{
904
    SubStream *s = &m->substream[substr];
905 9731e7f1 Ramiro Polla
    unsigned int i, out_ch = 0;
906 b517af05 Ramiro Polla
    int32_t *data_32 = (int32_t*) data;
907
    int16_t *data_16 = (int16_t*) data;
908
909
    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
910
        return -1;
911
912
    for (i = 0; i < s->blockpos; i++) {
913 9731e7f1 Ramiro Polla
        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
914
            int mat_ch = s->ch_assign[out_ch];
915
            int32_t sample = m->sample_buffer[i][mat_ch]
916
                          << s->output_shift[mat_ch];
917
            s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
918 b517af05 Ramiro Polla
            if (is32) *data_32++ = sample << 8;
919
            else      *data_16++ = sample >> 8;
920
        }
921
    }
922
923 9731e7f1 Ramiro Polla
    *data_size = i * out_ch * (is32 ? 4 : 2);
924 b517af05 Ramiro Polla
925
    return 0;
926
}
927
928
static int output_data(MLPDecodeContext *m, unsigned int substr,
929
                       uint8_t *data, unsigned int *data_size)
930
{
931
    if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
932
        return output_data_internal(m, substr, data, data_size, 1);
933
    else
934
        return output_data_internal(m, substr, data, data_size, 0);
935
}
936
937
938
/** Read an access unit from the stream.
939
 *  Returns < 0 on error, 0 if not enough data is present in the input stream
940
 *  otherwise returns the number of bytes consumed. */
941
942
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
943 7a00bbad Thilo Borgmann
                            AVPacket *avpkt)
944 b517af05 Ramiro Polla
{
945 7a00bbad Thilo Borgmann
    const uint8_t *buf = avpkt->data;
946
    int buf_size = avpkt->size;
947 b517af05 Ramiro Polla
    MLPDecodeContext *m = avctx->priv_data;
948
    GetBitContext gb;
949
    unsigned int length, substr;
950
    unsigned int substream_start;
951
    unsigned int header_size = 4;
952
    unsigned int substr_header_size = 0;
953
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
954
    uint16_t substream_data_len[MAX_SUBSTREAMS];
955
    uint8_t parity_bits;
956
957
    if (buf_size < 4)
958
        return 0;
959
960
    length = (AV_RB16(buf) & 0xfff) * 2;
961
962 0b882b40 Reimar Döffinger
    if (length < 4 || length > buf_size)
963 b517af05 Ramiro Polla
        return -1;
964
965
    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
966
967 cc9c5126 Ramiro Polla
    m->is_major_sync_unit = 0;
968 b517af05 Ramiro Polla
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
969
        if (read_major_sync(m, &gb) < 0)
970
            goto error;
971 cc9c5126 Ramiro Polla
        m->is_major_sync_unit = 1;
972 b517af05 Ramiro Polla
        header_size += 28;
973
    }
974
975
    if (!m->params_valid) {
976
        av_log(m->avctx, AV_LOG_WARNING,
977 9906a2be Diego Biurrun
               "Stream parameters not seen; skipping frame.\n");
978 b517af05 Ramiro Polla
        *data_size = 0;
979
        return length;
980
    }
981
982
    substream_start = 0;
983
984
    for (substr = 0; substr < m->num_substreams; substr++) {
985 cc9c5126 Ramiro Polla
        int extraword_present, checkdata_present, end, nonrestart_substr;
986 b517af05 Ramiro Polla
987
        extraword_present = get_bits1(&gb);
988 cc9c5126 Ramiro Polla
        nonrestart_substr = get_bits1(&gb);
989 b517af05 Ramiro Polla
        checkdata_present = get_bits1(&gb);
990
        skip_bits1(&gb);
991
992
        end = get_bits(&gb, 12) * 2;
993
994
        substr_header_size += 2;
995
996
        if (extraword_present) {
997 89e39be3 Ramiro Polla
            if (m->avctx->codec_id == CODEC_ID_MLP) {
998
                av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
999
                goto error;
1000
            }
1001 b517af05 Ramiro Polla
            skip_bits(&gb, 16);
1002
            substr_header_size += 2;
1003
        }
1004
1005 cc9c5126 Ramiro Polla
        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1006
            av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1007
            goto error;
1008
        }
1009
1010 b517af05 Ramiro Polla
        if (end + header_size + substr_header_size > length) {
1011
            av_log(m->avctx, AV_LOG_ERROR,
1012
                   "Indicated length of substream %d data goes off end of "
1013
                   "packet.\n", substr);
1014
            end = length - header_size - substr_header_size;
1015
        }
1016
1017
        if (end < substream_start) {
1018
            av_log(avctx, AV_LOG_ERROR,
1019
                   "Indicated end offset of substream %d data "
1020
                   "is smaller than calculated start offset.\n",
1021
                   substr);
1022
            goto error;
1023
        }
1024
1025
        if (substr > m->max_decoded_substream)
1026
            continue;
1027
1028
        substream_parity_present[substr] = checkdata_present;
1029
        substream_data_len[substr] = end - substream_start;
1030
        substream_start = end;
1031
    }
1032
1033 ce15710f Ramiro Polla
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
1034
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1035 b517af05 Ramiro Polla
1036
    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1037
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1038
        goto error;
1039
    }
1040
1041
    buf += header_size + substr_header_size;
1042
1043
    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1044
        SubStream *s = &m->substream[substr];
1045
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1046
1047 75428fa4 Ramiro Polla
        m->matrix_changed = 0;
1048
        memset(m->filter_changed, 0, sizeof(m->filter_changed));
1049
1050 b517af05 Ramiro Polla
        s->blockpos = 0;
1051
        do {
1052
            if (get_bits1(&gb)) {
1053
                if (get_bits1(&gb)) {
1054 9906a2be Diego Biurrun
                    /* A restart header should be present. */
1055 b517af05 Ramiro Polla
                    if (read_restart_header(m, &gb, buf, substr) < 0)
1056
                        goto next_substr;
1057
                    s->restart_seen = 1;
1058
                }
1059
1060 f95f6ab9 Ramiro Polla
                if (!s->restart_seen)
1061 b517af05 Ramiro Polla
                    goto next_substr;
1062
                if (read_decoding_params(m, &gb, substr) < 0)
1063
                    goto next_substr;
1064
            }
1065
1066 f95f6ab9 Ramiro Polla
            if (!s->restart_seen)
1067 b517af05 Ramiro Polla
                goto next_substr;
1068
1069
            if (read_block_data(m, &gb, substr) < 0)
1070
                return -1;
1071
1072 d7952be3 Ramiro Polla
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1073
                goto substream_length_mismatch;
1074
1075
        } while (!get_bits1(&gb));
1076 b517af05 Ramiro Polla
1077
        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1078 f95f6ab9 Ramiro Polla
1079 7b18e13a Ramiro Polla
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1080
            int shorten_by;
1081
1082
            if (get_bits(&gb, 16) != 0xD234)
1083
                return -1;
1084
1085
            shorten_by = get_bits(&gb, 16);
1086
            if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1087
                s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1088
            else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
1089
                return -1;
1090
1091 b517af05 Ramiro Polla
            if (substr == m->max_decoded_substream)
1092 9906a2be Diego Biurrun
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1093 b517af05 Ramiro Polla
        }
1094 f95f6ab9 Ramiro Polla
1095 ab79fa44 Ramiro Polla
        if (substream_parity_present[substr]) {
1096 b517af05 Ramiro Polla
            uint8_t parity, checksum;
1097
1098 ab79fa44 Ramiro Polla
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1099
                goto substream_length_mismatch;
1100
1101 d544dcdf Ramiro Polla
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1102
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1103 b517af05 Ramiro Polla
1104 d544dcdf Ramiro Polla
            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1105
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1106
            if ( get_bits(&gb, 8)           != checksum)
1107
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1108 b517af05 Ramiro Polla
        }
1109 f95f6ab9 Ramiro Polla
1110
        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1111 d7952be3 Ramiro Polla
            goto substream_length_mismatch;
1112 b517af05 Ramiro Polla
1113
next_substr:
1114 f95f6ab9 Ramiro Polla
        if (!s->restart_seen)
1115 01aaf092 Ramiro Polla
            av_log(m->avctx, AV_LOG_ERROR,
1116
                   "No restart header present in substream %d.\n", substr);
1117
1118 b517af05 Ramiro Polla
        buf += substream_data_len[substr];
1119
    }
1120
1121
    rematrix_channels(m, m->max_decoded_substream);
1122
1123
    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1124
        return -1;
1125
1126
    return length;
1127
1128 d7952be3 Ramiro Polla
substream_length_mismatch:
1129
    av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1130
    return -1;
1131
1132 b517af05 Ramiro Polla
error:
1133
    m->params_valid = 0;
1134
    return -1;
1135
}
1136
1137
AVCodec mlp_decoder = {
1138
    "mlp",
1139 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_AUDIO,
1140 b517af05 Ramiro Polla
    CODEC_ID_MLP,
1141
    sizeof(MLPDecodeContext),
1142
    mlp_decode_init,
1143
    NULL,
1144
    NULL,
1145
    read_access_unit,
1146 9ba4821d Ramiro Polla
    .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1147 b517af05 Ramiro Polla
};
1148
1149 9ba4821d Ramiro Polla
#if CONFIG_TRUEHD_DECODER
1150
AVCodec truehd_decoder = {
1151
    "truehd",
1152 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_AUDIO,
1153 9ba4821d Ramiro Polla
    CODEC_ID_TRUEHD,
1154
    sizeof(MLPDecodeContext),
1155
    mlp_decode_init,
1156
    NULL,
1157
    NULL,
1158
    read_access_unit,
1159
    .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1160
};
1161
#endif /* CONFIG_TRUEHD_DECODER */