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