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