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