mlpdec: Use some context arrays with local variables in rematrix_channels().
[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);
340
341 if (sync_word != 0x31ea >> 1) {
342 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 343 "restart header sync incorrect (got 0x%04x)\n", sync_word);
b517af05
RP
344 return -1;
345 }
346 s->noise_type = get_bits1(gbp);
347
348 skip_bits(gbp, 16); /* Output timestamp */
349
350 s->min_channel = get_bits(gbp, 4);
351 s->max_channel = get_bits(gbp, 4);
352 s->max_matrix_channel = get_bits(gbp, 4);
353
354 if (s->min_channel > s->max_channel) {
355 av_log(m->avctx, AV_LOG_ERROR,
356 "Substream min channel cannot be greater than max channel.\n");
357 return -1;
358 }
359
360 if (m->avctx->request_channels > 0
361 && s->max_channel + 1 >= m->avctx->request_channels
362 && substr < m->max_decoded_substream) {
363 av_log(m->avctx, AV_LOG_INFO,
364 "Extracting %d channel downmix from substream %d. "
365 "Further substreams will be skipped.\n",
366 s->max_channel + 1, substr);
367 m->max_decoded_substream = substr;
368 }
369
370 s->noise_shift = get_bits(gbp, 4);
371 s->noisegen_seed = get_bits(gbp, 23);
372
373 skip_bits(gbp, 19);
374
375 s->data_check_present = get_bits1(gbp);
376 lossless_check = get_bits(gbp, 8);
377 if (substr == m->max_decoded_substream
378 && s->lossless_check_data != 0xffffffff) {
a7cc783d 379 tmp = xor_32_to_8(s->lossless_check_data);
b517af05
RP
380 if (tmp != lossless_check)
381 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 382 "Lossless check failed - expected %02x, calculated %02x.\n",
b517af05 383 lossless_check, tmp);
b517af05
RP
384 }
385
386 skip_bits(gbp, 16);
387
9731e7f1
RP
388 memset(s->ch_assign, 0, sizeof(s->ch_assign));
389
b517af05
RP
390 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
391 int ch_assign = get_bits(gbp, 6);
9731e7f1 392 if (ch_assign > s->max_matrix_channel) {
b517af05 393 av_log(m->avctx, AV_LOG_ERROR,
9731e7f1
RP
394 "Assignment of matrix channel %d to invalid output channel %d. %s\n",
395 ch, ch_assign, sample_message);
b517af05
RP
396 return -1;
397 }
9731e7f1 398 s->ch_assign[ch_assign] = ch;
b517af05
RP
399 }
400
ce15710f 401 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
b517af05
RP
402
403 if (checksum != get_bits(gbp, 8))
9906a2be 404 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
b517af05 405
9906a2be 406 /* Set default decoding parameters. */
b517af05
RP
407 s->param_presence_flags = 0xff;
408 s->num_primitive_matrices = 0;
409 s->blocksize = 8;
410 s->lossless_check_data = 0;
411
412 memset(s->output_shift , 0, sizeof(s->output_shift ));
413 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
414
415 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
f53acb7b
RP
416 ChannelParams *cp = &m->channel_params[ch];
417 cp->filter_params[FIR].order = 0;
418 cp->filter_params[IIR].order = 0;
419 cp->filter_params[FIR].shift = 0;
420 cp->filter_params[IIR].shift = 0;
b517af05 421
9906a2be 422 /* Default audio coding is 24-bit raw PCM. */
f53acb7b
RP
423 cp->huff_offset = 0;
424 cp->sign_huff_offset = (-1) << 23;
425 cp->codebook = 0;
426 cp->huff_lsbs = 24;
b517af05
RP
427 }
428
429 if (substr == m->max_decoded_substream) {
9731e7f1 430 m->avctx->channels = s->max_matrix_channel + 1;
b517af05
RP
431 }
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)
b517af05
RP
627 if (get_bits1(gbp))
628 s->param_presence_flags = get_bits(gbp, 8);
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)
641 if (get_bits1(gbp)) {
95c14b1e 642 if (read_matrix_params(m, substr, gbp) < 0)
f8e6293b 643 return -1;
b517af05
RP
644 }
645
646 if (s->param_presence_flags & PARAM_OUTSHIFT)
647 if (get_bits1(gbp))
648 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
af048026 649 s->output_shift[ch] = get_sbits(gbp, 4);
b517af05
RP
650 }
651
652 if (s->param_presence_flags & PARAM_QUANTSTEP)
653 if (get_bits1(gbp))
654 for (ch = 0; ch <= s->max_channel; ch++) {
f53acb7b
RP
655 ChannelParams *cp = &m->channel_params[ch];
656
b517af05 657 s->quant_step_size[ch] = get_bits(gbp, 4);
b517af05 658
f53acb7b 659 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
b517af05
RP
660 }
661
662 for (ch = s->min_channel; ch <= s->max_channel; ch++)
663 if (get_bits1(gbp)) {
43ee5fe0 664 if (read_channel_params(m, substr, gbp, ch) < 0)
b517af05 665 return -1;
b517af05
RP
666 }
667
668 return 0;
669}
670
671#define MSB_MASK(bits) (-1u << bits)
672
673/** Generate PCM samples using the prediction filters and residual values
674 * read from the data stream, and update the filter state. */
675
676static void filter_channel(MLPDecodeContext *m, unsigned int substr,
677 unsigned int channel)
678{
679 SubStream *s = &m->substream[substr];
e71365f4
RP
680 int32_t firbuf[MAX_BLOCKSIZE + MAX_FIR_ORDER];
681 int32_t iirbuf[MAX_BLOCKSIZE + MAX_IIR_ORDER];
682 FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
683 FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
684 unsigned int filter_shift = fir->shift;
b517af05
RP
685 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
686 int index = MAX_BLOCKSIZE;
0ae59bb0 687 int i;
b517af05 688
06e34be8
RP
689 memcpy(&firbuf[index], fir->state, MAX_FIR_ORDER * sizeof(int32_t));
690 memcpy(&iirbuf[index], iir->state, MAX_IIR_ORDER * sizeof(int32_t));
b517af05
RP
691
692 for (i = 0; i < s->blocksize; i++) {
693 int32_t residual = m->sample_buffer[i + s->blockpos][channel];
694 unsigned int order;
695 int64_t accum = 0;
696 int32_t result;
697
698 /* TODO: Move this code to DSPContext? */
699
e71365f4 700 for (order = 0; order < fir->order; order++)
06e34be8 701 accum += (int64_t) firbuf[index + order] * fir->coeff[order];
e71365f4 702 for (order = 0; order < iir->order; order++)
06e34be8 703 accum += (int64_t) iirbuf[index + order] * iir->coeff[order];
b517af05
RP
704
705 accum = accum >> filter_shift;
706 result = (accum + residual) & mask;
707
708 --index;
709
e71365f4
RP
710 firbuf[index] = result;
711 iirbuf[index] = result - accum;
b517af05
RP
712
713 m->sample_buffer[i + s->blockpos][channel] = result;
714 }
715
06e34be8
RP
716 memcpy(fir->state, &firbuf[index], MAX_FIR_ORDER * sizeof(int32_t));
717 memcpy(iir->state, &iirbuf[index], MAX_IIR_ORDER * sizeof(int32_t));
b517af05
RP
718}
719
720/** Read a block of PCM residual data (or actual if no filtering active). */
721
722static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
723 unsigned int substr)
724{
725 SubStream *s = &m->substream[substr];
726 unsigned int i, ch, expected_stream_pos = 0;
727
728 if (s->data_check_present) {
729 expected_stream_pos = get_bits_count(gbp);
730 expected_stream_pos += get_bits(gbp, 16);
731 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
732 "we have not tested yet. %s\n", sample_message);
733 }
734
735 if (s->blockpos + s->blocksize > m->access_unit_size) {
9906a2be 736 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
b517af05
RP
737 return -1;
738 }
739
740 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
741 s->blocksize * sizeof(m->bypassed_lsbs[0]));
742
743 for (i = 0; i < s->blocksize; i++) {
744 if (read_huff_channels(m, gbp, substr, i) < 0)
745 return -1;
746 }
747
748 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
749 filter_channel(m, substr, ch);
750 }
751
752 s->blockpos += s->blocksize;
753
754 if (s->data_check_present) {
755 if (get_bits_count(gbp) != expected_stream_pos)
9906a2be 756 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
b517af05
RP
757 skip_bits(gbp, 8);
758 }
759
760 return 0;
761}
762
9906a2be 763/** Data table used for TrueHD noise generation function. */
b517af05
RP
764
765static const int8_t noise_table[256] = {
766 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
767 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
768 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
769 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
770 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
771 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
772 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
773 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
774 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
775 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
776 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
777 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
778 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
779 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
780 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
781 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
782};
783
784/** Noise generation functions.
785 * I'm not sure what these are for - they seem to be some kind of pseudorandom
786 * sequence generators, used to generate noise data which is used when the
787 * channels are rematrixed. I'm not sure if they provide a practical benefit
788 * to compression, or just obfuscate the decoder. Are they for some kind of
789 * dithering? */
790
791/** Generate two channels of noise, used in the matrix when
792 * restart sync word == 0x31ea. */
793
794static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
795{
796 SubStream *s = &m->substream[substr];
797 unsigned int i;
798 uint32_t seed = s->noisegen_seed;
799 unsigned int maxchan = s->max_matrix_channel;
800
801 for (i = 0; i < s->blockpos; i++) {
802 uint16_t seed_shr7 = seed >> 7;
803 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
804 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
805
806 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
807 }
808
809 s->noisegen_seed = seed;
810}
811
812/** Generate a block of noise, used when restart sync word == 0x31eb. */
813
814static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
815{
816 SubStream *s = &m->substream[substr];
817 unsigned int i;
818 uint32_t seed = s->noisegen_seed;
819
820 for (i = 0; i < m->access_unit_size_pow2; i++) {
821 uint8_t seed_shr15 = seed >> 15;
822 m->noise_buffer[i] = noise_table[seed_shr15];
823 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
824 }
825
826 s->noisegen_seed = seed;
827}
828
829
830/** Apply the channel matrices in turn to reconstruct the original audio
831 * samples. */
832
833static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
834{
835 SubStream *s = &m->substream[substr];
836 unsigned int mat, src_ch, i;
837 unsigned int maxchan;
838
839 maxchan = s->max_matrix_channel;
840 if (!s->noise_type) {
841 generate_2_noise_channels(m, substr);
842 maxchan += 2;
843 } else {
844 fill_noise_buffer(m, substr);
845 }
846
847 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
848 int matrix_noise_shift = s->matrix_noise_shift[mat];
849 unsigned int dest_ch = s->matrix_out_ch[mat];
850 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
63ad832d 851 int32_t *coeffs = s->matrix_coeff[mat];
15e6748b
RP
852 int index = s->num_primitive_matrices - mat;
853 int index2 = 2 * index + 1;
b517af05
RP
854
855 /* TODO: DSPContext? */
856
857 for (i = 0; i < s->blockpos; i++) {
63ad832d 858 int32_t *samples = m->sample_buffer[i];
b517af05
RP
859 int64_t accum = 0;
860 for (src_ch = 0; src_ch <= maxchan; src_ch++) {
63ad832d
RP
861 accum += (int64_t)samples[src_ch]
862 * coeffs[src_ch];
b517af05
RP
863 }
864 if (matrix_noise_shift) {
15e6748b 865 index &= m->access_unit_size_pow2 - 1;
b517af05 866 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
15e6748b 867 index += index2;
b517af05 868 }
63ad832d 869 samples[dest_ch] = ((accum >> 14) & mask)
b517af05
RP
870 + m->bypassed_lsbs[i][mat];
871 }
872 }
873}
874
875/** Write the audio data into the output buffer. */
876
877static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
878 uint8_t *data, unsigned int *data_size, int is32)
879{
880 SubStream *s = &m->substream[substr];
9731e7f1 881 unsigned int i, out_ch = 0;
b517af05
RP
882 int32_t *data_32 = (int32_t*) data;
883 int16_t *data_16 = (int16_t*) data;
884
885 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
886 return -1;
887
888 for (i = 0; i < s->blockpos; i++) {
9731e7f1
RP
889 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
890 int mat_ch = s->ch_assign[out_ch];
891 int32_t sample = m->sample_buffer[i][mat_ch]
892 << s->output_shift[mat_ch];
893 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
b517af05
RP
894 if (is32) *data_32++ = sample << 8;
895 else *data_16++ = sample >> 8;
896 }
897 }
898
9731e7f1 899 *data_size = i * out_ch * (is32 ? 4 : 2);
b517af05
RP
900
901 return 0;
902}
903
904static int output_data(MLPDecodeContext *m, unsigned int substr,
905 uint8_t *data, unsigned int *data_size)
906{
907 if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
908 return output_data_internal(m, substr, data, data_size, 1);
909 else
910 return output_data_internal(m, substr, data, data_size, 0);
911}
912
913
b517af05
RP
914/** Read an access unit from the stream.
915 * Returns < 0 on error, 0 if not enough data is present in the input stream
916 * otherwise returns the number of bytes consumed. */
917
918static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
7a00bbad 919 AVPacket *avpkt)
b517af05 920{
7a00bbad
TB
921 const uint8_t *buf = avpkt->data;
922 int buf_size = avpkt->size;
b517af05
RP
923 MLPDecodeContext *m = avctx->priv_data;
924 GetBitContext gb;
925 unsigned int length, substr;
926 unsigned int substream_start;
927 unsigned int header_size = 4;
928 unsigned int substr_header_size = 0;
929 uint8_t substream_parity_present[MAX_SUBSTREAMS];
930 uint16_t substream_data_len[MAX_SUBSTREAMS];
931 uint8_t parity_bits;
932
933 if (buf_size < 4)
934 return 0;
935
936 length = (AV_RB16(buf) & 0xfff) * 2;
937
938 if (length > buf_size)
939 return -1;
940
941 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
942
cc9c5126 943 m->is_major_sync_unit = 0;
b517af05 944 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
b517af05
RP
945 if (read_major_sync(m, &gb) < 0)
946 goto error;
cc9c5126 947 m->is_major_sync_unit = 1;
b517af05
RP
948 header_size += 28;
949 }
950
951 if (!m->params_valid) {
952 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 953 "Stream parameters not seen; skipping frame.\n");
b517af05
RP
954 *data_size = 0;
955 return length;
956 }
957
958 substream_start = 0;
959
960 for (substr = 0; substr < m->num_substreams; substr++) {
cc9c5126 961 int extraword_present, checkdata_present, end, nonrestart_substr;
b517af05
RP
962
963 extraword_present = get_bits1(&gb);
cc9c5126 964 nonrestart_substr = get_bits1(&gb);
b517af05
RP
965 checkdata_present = get_bits1(&gb);
966 skip_bits1(&gb);
967
968 end = get_bits(&gb, 12) * 2;
969
970 substr_header_size += 2;
971
972 if (extraword_present) {
89e39be3
RP
973 if (m->avctx->codec_id == CODEC_ID_MLP) {
974 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
975 goto error;
976 }
b517af05
RP
977 skip_bits(&gb, 16);
978 substr_header_size += 2;
979 }
980
cc9c5126
RP
981 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
982 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
983 goto error;
984 }
985
b517af05
RP
986 if (end + header_size + substr_header_size > length) {
987 av_log(m->avctx, AV_LOG_ERROR,
988 "Indicated length of substream %d data goes off end of "
989 "packet.\n", substr);
990 end = length - header_size - substr_header_size;
991 }
992
993 if (end < substream_start) {
994 av_log(avctx, AV_LOG_ERROR,
995 "Indicated end offset of substream %d data "
996 "is smaller than calculated start offset.\n",
997 substr);
998 goto error;
999 }
1000
1001 if (substr > m->max_decoded_substream)
1002 continue;
1003
1004 substream_parity_present[substr] = checkdata_present;
1005 substream_data_len[substr] = end - substream_start;
1006 substream_start = end;
1007 }
1008
ce15710f
RP
1009 parity_bits = ff_mlp_calculate_parity(buf, 4);
1010 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
b517af05
RP
1011
1012 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1013 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1014 goto error;
1015 }
1016
1017 buf += header_size + substr_header_size;
1018
1019 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1020 SubStream *s = &m->substream[substr];
1021 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1022
75428fa4
RP
1023 m->matrix_changed = 0;
1024 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1025
b517af05
RP
1026 s->blockpos = 0;
1027 do {
1028 if (get_bits1(&gb)) {
1029 if (get_bits1(&gb)) {
9906a2be 1030 /* A restart header should be present. */
b517af05
RP
1031 if (read_restart_header(m, &gb, buf, substr) < 0)
1032 goto next_substr;
1033 s->restart_seen = 1;
1034 }
1035
1036 if (!s->restart_seen) {
b517af05
RP
1037 goto next_substr;
1038 }
1039
1040 if (read_decoding_params(m, &gb, substr) < 0)
1041 goto next_substr;
1042 }
1043
1044 if (!s->restart_seen) {
b517af05
RP
1045 goto next_substr;
1046 }
1047
1048 if (read_block_data(m, &gb, substr) < 0)
1049 return -1;
1050
d7952be3
RP
1051 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1052 goto substream_length_mismatch;
1053
1054 } while (!get_bits1(&gb));
b517af05
RP
1055
1056 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
7b18e13a
RP
1057 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1058 int shorten_by;
1059
1060 if (get_bits(&gb, 16) != 0xD234)
1061 return -1;
1062
1063 shorten_by = get_bits(&gb, 16);
1064 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1065 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1066 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1067 return -1;
1068
b517af05 1069 if (substr == m->max_decoded_substream)
9906a2be 1070 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
b517af05 1071 }
ab79fa44 1072 if (substream_parity_present[substr]) {
b517af05
RP
1073 uint8_t parity, checksum;
1074
ab79fa44
RP
1075 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1076 goto substream_length_mismatch;
1077
d544dcdf
RP
1078 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1079 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
b517af05 1080
d544dcdf
RP
1081 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1082 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1083 if ( get_bits(&gb, 8) != checksum)
1084 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
b517af05
RP
1085 }
1086 if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
d7952be3 1087 goto substream_length_mismatch;
b517af05
RP
1088 }
1089
1090next_substr:
01aaf092
RP
1091 if (!s->restart_seen) {
1092 av_log(m->avctx, AV_LOG_ERROR,
1093 "No restart header present in substream %d.\n", substr);
1094 }
1095
b517af05
RP
1096 buf += substream_data_len[substr];
1097 }
1098
1099 rematrix_channels(m, m->max_decoded_substream);
1100
1101 if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1102 return -1;
1103
1104 return length;
1105
d7952be3
RP
1106substream_length_mismatch:
1107 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1108 return -1;
1109
b517af05
RP
1110error:
1111 m->params_valid = 0;
1112 return -1;
1113}
1114
9ba4821d 1115#if CONFIG_MLP_DECODER
b517af05
RP
1116AVCodec mlp_decoder = {
1117 "mlp",
1118 CODEC_TYPE_AUDIO,
1119 CODEC_ID_MLP,
1120 sizeof(MLPDecodeContext),
1121 mlp_decode_init,
1122 NULL,
1123 NULL,
1124 read_access_unit,
9ba4821d 1125 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
b517af05 1126};
9ba4821d 1127#endif /* CONFIG_MLP_DECODER */
b517af05 1128
9ba4821d
RP
1129#if CONFIG_TRUEHD_DECODER
1130AVCodec truehd_decoder = {
1131 "truehd",
1132 CODEC_TYPE_AUDIO,
1133 CODEC_ID_TRUEHD,
1134 sizeof(MLPDecodeContext),
1135 mlp_decode_init,
1136 NULL,
1137 NULL,
1138 read_access_unit,
1139 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1140};
1141#endif /* CONFIG_TRUEHD_DECODER */