Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mlpdec.c @ d3f126df

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