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