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