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