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