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