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