491fb864c0733cc36d76d521eb70340258e5ab20
[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 s->noise_type = get_bits1(gbp);
348
349 if ((m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) ||
350 sync_word != 0x31ea >> 1) {
351 av_log(m->avctx, AV_LOG_ERROR,
352 "restart header sync incorrect (got 0x%04x)\n", sync_word);
353 return -1;
354 }
355
356 skip_bits(gbp, 16); /* Output timestamp */
357
358 s->min_channel = get_bits(gbp, 4);
359 s->max_channel = get_bits(gbp, 4);
360 s->max_matrix_channel = get_bits(gbp, 4);
361
362 if (s->max_matrix_channel > max_matrix_channel) {
363 av_log(m->avctx, AV_LOG_ERROR,
364 "Max matrix channel cannot be greater than %d.\n",
365 max_matrix_channel);
366 return -1;
367 }
368
369 if (s->max_channel != s->max_matrix_channel) {
370 av_log(m->avctx, AV_LOG_ERROR,
371 "Max channel must be equal max matrix channel.\n");
372 return -1;
373 }
374
375 if (s->min_channel > s->max_channel) {
376 av_log(m->avctx, AV_LOG_ERROR,
377 "Substream min channel cannot be greater than max channel.\n");
378 return -1;
379 }
380
381 if (m->avctx->request_channels > 0
382 && s->max_channel + 1 >= m->avctx->request_channels
383 && substr < m->max_decoded_substream) {
384 av_log(m->avctx, AV_LOG_INFO,
385 "Extracting %d channel downmix from substream %d. "
386 "Further substreams will be skipped.\n",
387 s->max_channel + 1, substr);
388 m->max_decoded_substream = substr;
389 }
390
391 s->noise_shift = get_bits(gbp, 4);
392 s->noisegen_seed = get_bits(gbp, 23);
393
394 skip_bits(gbp, 19);
395
396 s->data_check_present = get_bits1(gbp);
397 lossless_check = get_bits(gbp, 8);
398 if (substr == m->max_decoded_substream
399 && s->lossless_check_data != 0xffffffff) {
400 tmp = xor_32_to_8(s->lossless_check_data);
401 if (tmp != lossless_check)
402 av_log(m->avctx, AV_LOG_WARNING,
403 "Lossless check failed - expected %02x, calculated %02x.\n",
404 lossless_check, tmp);
405 }
406
407 skip_bits(gbp, 16);
408
409 memset(s->ch_assign, 0, sizeof(s->ch_assign));
410
411 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
412 int ch_assign = get_bits(gbp, 6);
413 if (ch_assign > s->max_matrix_channel) {
414 av_log(m->avctx, AV_LOG_ERROR,
415 "Assignment of matrix channel %d to invalid output channel %d. %s\n",
416 ch, ch_assign, sample_message);
417 return -1;
418 }
419 s->ch_assign[ch_assign] = ch;
420 }
421
422 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
423
424 if (checksum != get_bits(gbp, 8))
425 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
426
427 /* Set default decoding parameters. */
428 s->param_presence_flags = 0xff;
429 s->num_primitive_matrices = 0;
430 s->blocksize = 8;
431 s->lossless_check_data = 0;
432
433 memset(s->output_shift , 0, sizeof(s->output_shift ));
434 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
435
436 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
437 ChannelParams *cp = &m->channel_params[ch];
438 cp->filter_params[FIR].order = 0;
439 cp->filter_params[IIR].order = 0;
440 cp->filter_params[FIR].shift = 0;
441 cp->filter_params[IIR].shift = 0;
442
443 /* Default audio coding is 24-bit raw PCM. */
444 cp->huff_offset = 0;
445 cp->sign_huff_offset = (-1) << 23;
446 cp->codebook = 0;
447 cp->huff_lsbs = 24;
448 }
449
450 if (substr == m->max_decoded_substream)
451 m->avctx->channels = s->max_matrix_channel + 1;
452
453 return 0;
454 }
455
456 /** Read parameters for one of the prediction filters. */
457
458 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
459 unsigned int channel, unsigned int filter)
460 {
461 FilterParams *fp = &m->channel_params[channel].filter_params[filter];
462 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
463 const char fchar = filter ? 'I' : 'F';
464 int i, order;
465
466 // Filter is 0 for FIR, 1 for IIR.
467 assert(filter < 2);
468
469 if (m->filter_changed[channel][filter]++ > 1) {
470 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
471 return -1;
472 }
473
474 order = get_bits(gbp, 4);
475 if (order > max_order) {
476 av_log(m->avctx, AV_LOG_ERROR,
477 "%cIR filter order %d is greater than maximum %d.\n",
478 fchar, order, max_order);
479 return -1;
480 }
481 fp->order = order;
482
483 if (order > 0) {
484 int coeff_bits, coeff_shift;
485
486 fp->shift = get_bits(gbp, 4);
487
488 coeff_bits = get_bits(gbp, 5);
489 coeff_shift = get_bits(gbp, 3);
490 if (coeff_bits < 1 || coeff_bits > 16) {
491 av_log(m->avctx, AV_LOG_ERROR,
492 "%cIR filter coeff_bits must be between 1 and 16.\n",
493 fchar);
494 return -1;
495 }
496 if (coeff_bits + coeff_shift > 16) {
497 av_log(m->avctx, AV_LOG_ERROR,
498 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
499 fchar);
500 return -1;
501 }
502
503 for (i = 0; i < order; i++)
504 fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
505
506 if (get_bits1(gbp)) {
507 int state_bits, state_shift;
508
509 if (filter == FIR) {
510 av_log(m->avctx, AV_LOG_ERROR,
511 "FIR filter has state data specified.\n");
512 return -1;
513 }
514
515 state_bits = get_bits(gbp, 4);
516 state_shift = get_bits(gbp, 4);
517
518 /* TODO: Check validity of state data. */
519
520 for (i = 0; i < order; i++)
521 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
522 }
523 }
524
525 return 0;
526 }
527
528 /** Read parameters for primitive matrices. */
529
530 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
531 {
532 SubStream *s = &m->substream[substr];
533 unsigned int mat, ch;
534 const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
535 ? MAX_MATRICES_MLP
536 : MAX_MATRICES_TRUEHD;
537
538 if (m->matrix_changed++ > 1) {
539 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
540 return -1;
541 }
542
543 s->num_primitive_matrices = get_bits(gbp, 4);
544
545 if (s->num_primitive_matrices > max_primitive_matrices) {
546 av_log(m->avctx, AV_LOG_ERROR,
547 "Number of primitive matrices cannot be greater than %d.\n",
548 max_primitive_matrices);
549 return -1;
550 }
551
552 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
553 int frac_bits, max_chan;
554 s->matrix_out_ch[mat] = get_bits(gbp, 4);
555 frac_bits = get_bits(gbp, 4);
556 s->lsb_bypass [mat] = get_bits1(gbp);
557
558 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
559 av_log(m->avctx, AV_LOG_ERROR,
560 "Invalid channel %d specified as output from matrix.\n",
561 s->matrix_out_ch[mat]);
562 return -1;
563 }
564 if (frac_bits > 14) {
565 av_log(m->avctx, AV_LOG_ERROR,
566 "Too many fractional bits specified.\n");
567 return -1;
568 }
569
570 max_chan = s->max_matrix_channel;
571 if (!s->noise_type)
572 max_chan+=2;
573
574 for (ch = 0; ch <= max_chan; ch++) {
575 int coeff_val = 0;
576 if (get_bits1(gbp))
577 coeff_val = get_sbits(gbp, frac_bits + 2);
578
579 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
580 }
581
582 if (s->noise_type)
583 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
584 else
585 s->matrix_noise_shift[mat] = 0;
586 }
587
588 return 0;
589 }
590
591 /** Read channel parameters. */
592
593 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
594 GetBitContext *gbp, unsigned int ch)
595 {
596 ChannelParams *cp = &m->channel_params[ch];
597 FilterParams *fir = &cp->filter_params[FIR];
598 FilterParams *iir = &cp->filter_params[IIR];
599 SubStream *s = &m->substream[substr];
600
601 if (s->param_presence_flags & PARAM_FIR)
602 if (get_bits1(gbp))
603 if (read_filter_params(m, gbp, ch, FIR) < 0)
604 return -1;
605
606 if (s->param_presence_flags & PARAM_IIR)
607 if (get_bits1(gbp))
608 if (read_filter_params(m, gbp, ch, IIR) < 0)
609 return -1;
610
611 if (fir->order + iir->order > 8) {
612 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
613 return -1;
614 }
615
616 if (fir->order && iir->order &&
617 fir->shift != iir->shift) {
618 av_log(m->avctx, AV_LOG_ERROR,
619 "FIR and IIR filters must use the same precision.\n");
620 return -1;
621 }
622 /* The FIR and IIR filters must have the same precision.
623 * To simplify the filtering code, only the precision of the
624 * FIR filter is considered. If only the IIR filter is employed,
625 * the FIR filter precision is set to that of the IIR filter, so
626 * that the filtering code can use it. */
627 if (!fir->order && iir->order)
628 fir->shift = iir->shift;
629
630 if (s->param_presence_flags & PARAM_HUFFOFFSET)
631 if (get_bits1(gbp))
632 cp->huff_offset = get_sbits(gbp, 15);
633
634 cp->codebook = get_bits(gbp, 2);
635 cp->huff_lsbs = get_bits(gbp, 5);
636
637 if (cp->huff_lsbs > 24) {
638 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
639 return -1;
640 }
641
642 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
643
644 return 0;
645 }
646
647 /** Read decoding parameters that change more often than those in the restart
648 * header. */
649
650 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
651 unsigned int substr)
652 {
653 SubStream *s = &m->substream[substr];
654 unsigned int ch;
655
656 if (s->param_presence_flags & PARAM_PRESENCE)
657 if (get_bits1(gbp))
658 s->param_presence_flags = get_bits(gbp, 8);
659
660 if (s->param_presence_flags & PARAM_BLOCKSIZE)
661 if (get_bits1(gbp)) {
662 s->blocksize = get_bits(gbp, 9);
663 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
664 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
665 s->blocksize = 0;
666 return -1;
667 }
668 }
669
670 if (s->param_presence_flags & PARAM_MATRIX)
671 if (get_bits1(gbp))
672 if (read_matrix_params(m, substr, gbp) < 0)
673 return -1;
674
675 if (s->param_presence_flags & PARAM_OUTSHIFT)
676 if (get_bits1(gbp))
677 for (ch = 0; ch <= s->max_matrix_channel; ch++)
678 s->output_shift[ch] = get_sbits(gbp, 4);
679
680 if (s->param_presence_flags & PARAM_QUANTSTEP)
681 if (get_bits1(gbp))
682 for (ch = 0; ch <= s->max_channel; ch++) {
683 ChannelParams *cp = &m->channel_params[ch];
684
685 s->quant_step_size[ch] = get_bits(gbp, 4);
686
687 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
688 }
689
690 for (ch = s->min_channel; ch <= s->max_channel; ch++)
691 if (get_bits1(gbp))
692 if (read_channel_params(m, substr, gbp, ch) < 0)
693 return -1;
694
695 return 0;
696 }
697
698 #define MSB_MASK(bits) (-1u << bits)
699
700 /** Generate PCM samples using the prediction filters and residual values
701 * read from the data stream, and update the filter state. */
702
703 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
704 unsigned int channel)
705 {
706 SubStream *s = &m->substream[substr];
707 int32_t fir_state_buffer[MAX_BLOCKSIZE + MAX_FIR_ORDER];
708 int32_t iir_state_buffer[MAX_BLOCKSIZE + MAX_IIR_ORDER];
709 int32_t *firbuf = fir_state_buffer + MAX_BLOCKSIZE;
710 int32_t *iirbuf = iir_state_buffer + MAX_BLOCKSIZE;
711 FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
712 FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
713 unsigned int filter_shift = fir->shift;
714 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
715
716 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
717 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
718
719 m->dsp.mlp_filter_channel(firbuf, fir->coeff, fir->order,
720 iirbuf, iir->coeff, iir->order,
721 filter_shift, mask, s->blocksize,
722 &m->sample_buffer[s->blockpos][channel]);
723
724 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
725 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
726 }
727
728 /** Read a block of PCM residual data (or actual if no filtering active). */
729
730 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
731 unsigned int substr)
732 {
733 SubStream *s = &m->substream[substr];
734 unsigned int i, ch, expected_stream_pos = 0;
735
736 if (s->data_check_present) {
737 expected_stream_pos = get_bits_count(gbp);
738 expected_stream_pos += get_bits(gbp, 16);
739 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
740 "we have not tested yet. %s\n", sample_message);
741 }
742
743 if (s->blockpos + s->blocksize > m->access_unit_size) {
744 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
745 return -1;
746 }
747
748 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
749 s->blocksize * sizeof(m->bypassed_lsbs[0]));
750
751 for (i = 0; i < s->blocksize; i++)
752 if (read_huff_channels(m, gbp, substr, i) < 0)
753 return -1;
754
755 for (ch = s->min_channel; ch <= s->max_channel; ch++)
756 filter_channel(m, substr, ch);
757
758 s->blockpos += s->blocksize;
759
760 if (s->data_check_present) {
761 if (get_bits_count(gbp) != expected_stream_pos)
762 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
763 skip_bits(gbp, 8);
764 }
765
766 return 0;
767 }
768
769 /** Data table used for TrueHD noise generation function. */
770
771 static const int8_t noise_table[256] = {
772 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
773 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
774 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
775 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
776 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
777 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
778 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
779 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
780 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
781 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
782 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
783 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
784 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
785 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
786 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
787 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
788 };
789
790 /** Noise generation functions.
791 * I'm not sure what these are for - they seem to be some kind of pseudorandom
792 * sequence generators, used to generate noise data which is used when the
793 * channels are rematrixed. I'm not sure if they provide a practical benefit
794 * to compression, or just obfuscate the decoder. Are they for some kind of
795 * dithering? */
796
797 /** Generate two channels of noise, used in the matrix when
798 * restart sync word == 0x31ea. */
799
800 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
801 {
802 SubStream *s = &m->substream[substr];
803 unsigned int i;
804 uint32_t seed = s->noisegen_seed;
805 unsigned int maxchan = s->max_matrix_channel;
806
807 for (i = 0; i < s->blockpos; i++) {
808 uint16_t seed_shr7 = seed >> 7;
809 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
810 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
811
812 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
813 }
814
815 s->noisegen_seed = seed;
816 }
817
818 /** Generate a block of noise, used when restart sync word == 0x31eb. */
819
820 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
821 {
822 SubStream *s = &m->substream[substr];
823 unsigned int i;
824 uint32_t seed = s->noisegen_seed;
825
826 for (i = 0; i < m->access_unit_size_pow2; i++) {
827 uint8_t seed_shr15 = seed >> 15;
828 m->noise_buffer[i] = noise_table[seed_shr15];
829 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
830 }
831
832 s->noisegen_seed = seed;
833 }
834
835
836 /** Apply the channel matrices in turn to reconstruct the original audio
837 * samples. */
838
839 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
840 {
841 SubStream *s = &m->substream[substr];
842 unsigned int mat, src_ch, i;
843 unsigned int maxchan;
844
845 maxchan = s->max_matrix_channel;
846 if (!s->noise_type) {
847 generate_2_noise_channels(m, substr);
848 maxchan += 2;
849 } else {
850 fill_noise_buffer(m, substr);
851 }
852
853 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
854 int matrix_noise_shift = s->matrix_noise_shift[mat];
855 unsigned int dest_ch = s->matrix_out_ch[mat];
856 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
857 int32_t *coeffs = s->matrix_coeff[mat];
858 int index = s->num_primitive_matrices - mat;
859 int index2 = 2 * index + 1;
860
861 /* TODO: DSPContext? */
862
863 for (i = 0; i < s->blockpos; i++) {
864 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
865 int32_t *samples = m->sample_buffer[i];
866 int64_t accum = 0;
867
868 for (src_ch = 0; src_ch <= maxchan; src_ch++)
869 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
870
871 if (matrix_noise_shift) {
872 index &= m->access_unit_size_pow2 - 1;
873 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
874 index += index2;
875 }
876
877 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
878 }
879 }
880 }
881
882 /** Write the audio data into the output buffer. */
883
884 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
885 uint8_t *data, unsigned int *data_size, int is32)
886 {
887 SubStream *s = &m->substream[substr];
888 unsigned int i, out_ch = 0;
889 int32_t *data_32 = (int32_t*) data;
890 int16_t *data_16 = (int16_t*) data;
891
892 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
893 return -1;
894
895 for (i = 0; i < s->blockpos; i++) {
896 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
897 int mat_ch = s->ch_assign[out_ch];
898 int32_t sample = m->sample_buffer[i][mat_ch]
899 << s->output_shift[mat_ch];
900 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
901 if (is32) *data_32++ = sample << 8;
902 else *data_16++ = sample >> 8;
903 }
904 }
905
906 *data_size = i * out_ch * (is32 ? 4 : 2);
907
908 return 0;
909 }
910
911 static int output_data(MLPDecodeContext *m, unsigned int substr,
912 uint8_t *data, unsigned int *data_size)
913 {
914 if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
915 return output_data_internal(m, substr, data, data_size, 1);
916 else
917 return output_data_internal(m, substr, data, data_size, 0);
918 }
919
920
921 /** Read an access unit from the stream.
922 * Returns < 0 on error, 0 if not enough data is present in the input stream
923 * otherwise returns the number of bytes consumed. */
924
925 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
926 AVPacket *avpkt)
927 {
928 const uint8_t *buf = avpkt->data;
929 int buf_size = avpkt->size;
930 MLPDecodeContext *m = avctx->priv_data;
931 GetBitContext gb;
932 unsigned int length, substr;
933 unsigned int substream_start;
934 unsigned int header_size = 4;
935 unsigned int substr_header_size = 0;
936 uint8_t substream_parity_present[MAX_SUBSTREAMS];
937 uint16_t substream_data_len[MAX_SUBSTREAMS];
938 uint8_t parity_bits;
939
940 if (buf_size < 4)
941 return 0;
942
943 length = (AV_RB16(buf) & 0xfff) * 2;
944
945 if (length > buf_size)
946 return -1;
947
948 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
949
950 m->is_major_sync_unit = 0;
951 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
952 if (read_major_sync(m, &gb) < 0)
953 goto error;
954 m->is_major_sync_unit = 1;
955 header_size += 28;
956 }
957
958 if (!m->params_valid) {
959 av_log(m->avctx, AV_LOG_WARNING,
960 "Stream parameters not seen; skipping frame.\n");
961 *data_size = 0;
962 return length;
963 }
964
965 substream_start = 0;
966
967 for (substr = 0; substr < m->num_substreams; substr++) {
968 int extraword_present, checkdata_present, end, nonrestart_substr;
969
970 extraword_present = get_bits1(&gb);
971 nonrestart_substr = get_bits1(&gb);
972 checkdata_present = get_bits1(&gb);
973 skip_bits1(&gb);
974
975 end = get_bits(&gb, 12) * 2;
976
977 substr_header_size += 2;
978
979 if (extraword_present) {
980 if (m->avctx->codec_id == CODEC_ID_MLP) {
981 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
982 goto error;
983 }
984 skip_bits(&gb, 16);
985 substr_header_size += 2;
986 }
987
988 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
989 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
990 goto error;
991 }
992
993 if (end + header_size + substr_header_size > length) {
994 av_log(m->avctx, AV_LOG_ERROR,
995 "Indicated length of substream %d data goes off end of "
996 "packet.\n", substr);
997 end = length - header_size - substr_header_size;
998 }
999
1000 if (end < substream_start) {
1001 av_log(avctx, AV_LOG_ERROR,
1002 "Indicated end offset of substream %d data "
1003 "is smaller than calculated start offset.\n",
1004 substr);
1005 goto error;
1006 }
1007
1008 if (substr > m->max_decoded_substream)
1009 continue;
1010
1011 substream_parity_present[substr] = checkdata_present;
1012 substream_data_len[substr] = end - substream_start;
1013 substream_start = end;
1014 }
1015
1016 parity_bits = ff_mlp_calculate_parity(buf, 4);
1017 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1018
1019 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1020 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1021 goto error;
1022 }
1023
1024 buf += header_size + substr_header_size;
1025
1026 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1027 SubStream *s = &m->substream[substr];
1028 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1029
1030 m->matrix_changed = 0;
1031 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1032
1033 s->blockpos = 0;
1034 do {
1035 if (get_bits1(&gb)) {
1036 if (get_bits1(&gb)) {
1037 /* A restart header should be present. */
1038 if (read_restart_header(m, &gb, buf, substr) < 0)
1039 goto next_substr;
1040 s->restart_seen = 1;
1041 }
1042
1043 if (!s->restart_seen)
1044 goto next_substr;
1045 if (read_decoding_params(m, &gb, substr) < 0)
1046 goto next_substr;
1047 }
1048
1049 if (!s->restart_seen)
1050 goto next_substr;
1051
1052 if (read_block_data(m, &gb, substr) < 0)
1053 return -1;
1054
1055 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1056 goto substream_length_mismatch;
1057
1058 } while (!get_bits1(&gb));
1059
1060 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1061
1062 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1063 int shorten_by;
1064
1065 if (get_bits(&gb, 16) != 0xD234)
1066 return -1;
1067
1068 shorten_by = get_bits(&gb, 16);
1069 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1070 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1071 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1072 return -1;
1073
1074 if (substr == m->max_decoded_substream)
1075 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1076 }
1077
1078 if (substream_parity_present[substr]) {
1079 uint8_t parity, checksum;
1080
1081 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1082 goto substream_length_mismatch;
1083
1084 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1085 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1086
1087 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1088 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1089 if ( get_bits(&gb, 8) != checksum)
1090 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1091 }
1092
1093 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1094 goto substream_length_mismatch;
1095
1096 next_substr:
1097 if (!s->restart_seen)
1098 av_log(m->avctx, AV_LOG_ERROR,
1099 "No restart header present in substream %d.\n", substr);
1100
1101 buf += substream_data_len[substr];
1102 }
1103
1104 rematrix_channels(m, m->max_decoded_substream);
1105
1106 if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1107 return -1;
1108
1109 return length;
1110
1111 substream_length_mismatch:
1112 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1113 return -1;
1114
1115 error:
1116 m->params_valid = 0;
1117 return -1;
1118 }
1119
1120 #if CONFIG_MLP_DECODER
1121 AVCodec mlp_decoder = {
1122 "mlp",
1123 CODEC_TYPE_AUDIO,
1124 CODEC_ID_MLP,
1125 sizeof(MLPDecodeContext),
1126 mlp_decode_init,
1127 NULL,
1128 NULL,
1129 read_access_unit,
1130 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1131 };
1132 #endif /* CONFIG_MLP_DECODER */
1133
1134 #if CONFIG_TRUEHD_DECODER
1135 AVCodec truehd_decoder = {
1136 "truehd",
1137 CODEC_TYPE_AUDIO,
1138 CODEC_ID_TRUEHD,
1139 sizeof(MLPDecodeContext),
1140 mlp_decode_init,
1141 NULL,
1142 NULL,
1143 read_access_unit,
1144 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1145 };
1146 #endif /* CONFIG_TRUEHD_DECODER */