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