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