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