c286c3b79262c9dcc864102826faab379c4308f4
[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 > MAX_BLOCKSIZE) {
613                 av_log(m->avctx, AV_LOG_ERROR, "block size too large\n");
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_bits(gbp, 4);
629                 dprintf(m->avctx, "output shift[%d] = %d\n",
630                         ch, s->output_shift[ch]);
631                 /* TODO: validate */
632             }
633
634     if (s->param_presence_flags & PARAM_QUANTSTEP)
635         if (get_bits1(gbp))
636             for (ch = 0; ch <= s->max_channel; ch++) {
637                 ChannelParams *cp = &m->channel_params[ch];
638
639                 s->quant_step_size[ch] = get_bits(gbp, 4);
640                 /* TODO: validate */
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 filter_state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FILTER_ORDER];
664     FilterParams *fp[NUM_FILTERS] = { &m->channel_params[channel].filter_params[FIR],
665                                       &m->channel_params[channel].filter_params[IIR], };
666     unsigned int filter_shift = fp[FIR]->shift;
667     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
668     int index = MAX_BLOCKSIZE;
669     int j, i;
670
671     for (j = 0; j < NUM_FILTERS; j++) {
672         memcpy(&filter_state_buffer[j][MAX_BLOCKSIZE], &fp[j]->state[0],
673                MAX_FILTER_ORDER * sizeof(int32_t));
674     }
675
676     for (i = 0; i < s->blocksize; i++) {
677         int32_t residual = m->sample_buffer[i + s->blockpos][channel];
678         unsigned int order;
679         int64_t accum = 0;
680         int32_t result;
681
682         /* TODO: Move this code to DSPContext? */
683
684         for (j = 0; j < NUM_FILTERS; j++)
685             for (order = 0; order < fp[j]->order; order++)
686                 accum += (int64_t)filter_state_buffer[j][index + order] *
687                                   fp[j]->coeff[order];
688
689         accum  = accum >> filter_shift;
690         result = (accum + residual) & mask;
691
692         --index;
693
694         filter_state_buffer[FIR][index] = result;
695         filter_state_buffer[IIR][index] = result - accum;
696
697         m->sample_buffer[i + s->blockpos][channel] = result;
698     }
699
700     for (j = 0; j < NUM_FILTERS; j++) {
701         memcpy(&fp[j]->state[0], &filter_state_buffer[j][index],
702                MAX_FILTER_ORDER * sizeof(int32_t));
703     }
704 }
705
706 /** Read a block of PCM residual data (or actual if no filtering active). */
707
708 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
709                            unsigned int substr)
710 {
711     SubStream *s = &m->substream[substr];
712     unsigned int i, ch, expected_stream_pos = 0;
713
714     if (s->data_check_present) {
715         expected_stream_pos  = get_bits_count(gbp);
716         expected_stream_pos += get_bits(gbp, 16);
717         av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
718                "we have not tested yet. %s\n", sample_message);
719     }
720
721     if (s->blockpos + s->blocksize > m->access_unit_size) {
722         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
723         return -1;
724     }
725
726     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
727            s->blocksize * sizeof(m->bypassed_lsbs[0]));
728
729     for (i = 0; i < s->blocksize; i++) {
730         if (read_huff_channels(m, gbp, substr, i) < 0)
731             return -1;
732     }
733
734     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
735         filter_channel(m, substr, ch);
736     }
737
738     s->blockpos += s->blocksize;
739
740     if (s->data_check_present) {
741         if (get_bits_count(gbp) != expected_stream_pos)
742             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
743         skip_bits(gbp, 8);
744     }
745
746     return 0;
747 }
748
749 /** Data table used for TrueHD noise generation function. */
750
751 static const int8_t noise_table[256] = {
752      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
753      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
754      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
755      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
756      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
757      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
758      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
759      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
760       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
761      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
762      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
763      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
764      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
765      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
766      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
767     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
768 };
769
770 /** Noise generation functions.
771  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
772  *  sequence generators, used to generate noise data which is used when the
773  *  channels are rematrixed. I'm not sure if they provide a practical benefit
774  *  to compression, or just obfuscate the decoder. Are they for some kind of
775  *  dithering? */
776
777 /** Generate two channels of noise, used in the matrix when
778  *  restart sync word == 0x31ea. */
779
780 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
781 {
782     SubStream *s = &m->substream[substr];
783     unsigned int i;
784     uint32_t seed = s->noisegen_seed;
785     unsigned int maxchan = s->max_matrix_channel;
786
787     for (i = 0; i < s->blockpos; i++) {
788         uint16_t seed_shr7 = seed >> 7;
789         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
790         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
791
792         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
793     }
794
795     s->noisegen_seed = seed;
796 }
797
798 /** Generate a block of noise, used when restart sync word == 0x31eb. */
799
800 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
801 {
802     SubStream *s = &m->substream[substr];
803     unsigned int i;
804     uint32_t seed = s->noisegen_seed;
805
806     for (i = 0; i < m->access_unit_size_pow2; i++) {
807         uint8_t seed_shr15 = seed >> 15;
808         m->noise_buffer[i] = noise_table[seed_shr15];
809         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
810     }
811
812     s->noisegen_seed = seed;
813 }
814
815
816 /** Apply the channel matrices in turn to reconstruct the original audio
817  *  samples. */
818
819 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
820 {
821     SubStream *s = &m->substream[substr];
822     unsigned int mat, src_ch, i;
823     unsigned int maxchan;
824
825     maxchan = s->max_matrix_channel;
826     if (!s->noise_type) {
827         generate_2_noise_channels(m, substr);
828         maxchan += 2;
829     } else {
830         fill_noise_buffer(m, substr);
831     }
832
833     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
834         int matrix_noise_shift = s->matrix_noise_shift[mat];
835         unsigned int dest_ch = s->matrix_out_ch[mat];
836         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
837
838         /* TODO: DSPContext? */
839
840         for (i = 0; i < s->blockpos; i++) {
841             int64_t accum = 0;
842             for (src_ch = 0; src_ch <= maxchan; src_ch++) {
843                 accum += (int64_t)m->sample_buffer[i][src_ch]
844                                   * s->matrix_coeff[mat][src_ch];
845             }
846             if (matrix_noise_shift) {
847                 uint32_t index = s->num_primitive_matrices - mat;
848                 index = (i * (index * 2 + 1) + index) & (m->access_unit_size_pow2 - 1);
849                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
850             }
851             m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
852                                              + m->bypassed_lsbs[i][mat];
853         }
854     }
855 }
856
857 /** Write the audio data into the output buffer. */
858
859 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
860                                 uint8_t *data, unsigned int *data_size, int is32)
861 {
862     SubStream *s = &m->substream[substr];
863     unsigned int i, out_ch = 0;
864     int32_t *data_32 = (int32_t*) data;
865     int16_t *data_16 = (int16_t*) data;
866
867     if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
868         return -1;
869
870     for (i = 0; i < s->blockpos; i++) {
871         for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
872             int mat_ch = s->ch_assign[out_ch];
873             int32_t sample = m->sample_buffer[i][mat_ch]
874                           << s->output_shift[mat_ch];
875             s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
876             if (is32) *data_32++ = sample << 8;
877             else      *data_16++ = sample >> 8;
878         }
879     }
880
881     *data_size = i * out_ch * (is32 ? 4 : 2);
882
883     return 0;
884 }
885
886 static int output_data(MLPDecodeContext *m, unsigned int substr,
887                        uint8_t *data, unsigned int *data_size)
888 {
889     if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
890         return output_data_internal(m, substr, data, data_size, 1);
891     else
892         return output_data_internal(m, substr, data, data_size, 0);
893 }
894
895
896 /** Read an access unit from the stream.
897  *  Returns < 0 on error, 0 if not enough data is present in the input stream
898  *  otherwise returns the number of bytes consumed. */
899
900 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
901                             const uint8_t *buf, int buf_size)
902 {
903     MLPDecodeContext *m = avctx->priv_data;
904     GetBitContext gb;
905     unsigned int length, substr;
906     unsigned int substream_start;
907     unsigned int header_size = 4;
908     unsigned int substr_header_size = 0;
909     uint8_t substream_parity_present[MAX_SUBSTREAMS];
910     uint16_t substream_data_len[MAX_SUBSTREAMS];
911     uint8_t parity_bits;
912
913     if (buf_size < 4)
914         return 0;
915
916     length = (AV_RB16(buf) & 0xfff) * 2;
917
918     if (length > buf_size)
919         return -1;
920
921     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
922
923     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
924         dprintf(m->avctx, "Found major sync.\n");
925         if (read_major_sync(m, &gb) < 0)
926             goto error;
927         header_size += 28;
928     }
929
930     if (!m->params_valid) {
931         av_log(m->avctx, AV_LOG_WARNING,
932                "Stream parameters not seen; skipping frame.\n");
933         *data_size = 0;
934         return length;
935     }
936
937     substream_start = 0;
938
939     for (substr = 0; substr < m->num_substreams; substr++) {
940         int extraword_present, checkdata_present, end;
941
942         extraword_present = get_bits1(&gb);
943         skip_bits1(&gb);
944         checkdata_present = get_bits1(&gb);
945         skip_bits1(&gb);
946
947         end = get_bits(&gb, 12) * 2;
948
949         substr_header_size += 2;
950
951         if (extraword_present) {
952             skip_bits(&gb, 16);
953             substr_header_size += 2;
954         }
955
956         if (end + header_size + substr_header_size > length) {
957             av_log(m->avctx, AV_LOG_ERROR,
958                    "Indicated length of substream %d data goes off end of "
959                    "packet.\n", substr);
960             end = length - header_size - substr_header_size;
961         }
962
963         if (end < substream_start) {
964             av_log(avctx, AV_LOG_ERROR,
965                    "Indicated end offset of substream %d data "
966                    "is smaller than calculated start offset.\n",
967                    substr);
968             goto error;
969         }
970
971         if (substr > m->max_decoded_substream)
972             continue;
973
974         substream_parity_present[substr] = checkdata_present;
975         substream_data_len[substr] = end - substream_start;
976         substream_start = end;
977     }
978
979     parity_bits  = ff_mlp_calculate_parity(buf, 4);
980     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
981
982     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
983         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
984         goto error;
985     }
986
987     buf += header_size + substr_header_size;
988
989     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
990         SubStream *s = &m->substream[substr];
991         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
992
993         s->blockpos = 0;
994         do {
995             if (get_bits1(&gb)) {
996                 if (get_bits1(&gb)) {
997                     /* A restart header should be present. */
998                     if (read_restart_header(m, &gb, buf, substr) < 0)
999                         goto next_substr;
1000                     s->restart_seen = 1;
1001                 }
1002
1003                 if (!s->restart_seen) {
1004                     av_log(m->avctx, AV_LOG_ERROR,
1005                            "No restart header present in substream %d.\n",
1006                            substr);
1007                     goto next_substr;
1008                 }
1009
1010                 if (read_decoding_params(m, &gb, substr) < 0)
1011                     goto next_substr;
1012             }
1013
1014             if (!s->restart_seen) {
1015                 av_log(m->avctx, AV_LOG_ERROR,
1016                        "No restart header present in substream %d.\n",
1017                        substr);
1018                 goto next_substr;
1019             }
1020
1021             if (read_block_data(m, &gb, substr) < 0)
1022                 return -1;
1023
1024         } while ((get_bits_count(&gb) < substream_data_len[substr] * 8)
1025                  && get_bits1(&gb) == 0);
1026
1027         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1028         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32 &&
1029             (show_bits_long(&gb, 32) == END_OF_STREAM ||
1030              show_bits_long(&gb, 20) == 0xd234e)) {
1031             skip_bits(&gb, 18);
1032             if (substr == m->max_decoded_substream)
1033                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1034
1035             if (get_bits1(&gb)) {
1036                 int shorten_by = get_bits(&gb, 13);
1037                 shorten_by = FFMIN(shorten_by, s->blockpos);
1038                 s->blockpos -= shorten_by;
1039             } else
1040                 skip_bits(&gb, 13);
1041         }
1042         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 16 &&
1043             substream_parity_present[substr]) {
1044             uint8_t parity, checksum;
1045
1046             parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1047             if ((parity ^ get_bits(&gb, 8)) != 0xa9)
1048                 av_log(m->avctx, AV_LOG_ERROR,
1049                        "Substream %d parity check failed.\n", substr);
1050
1051             checksum = ff_mlp_checksum8(buf, substream_data_len[substr] - 2);
1052             if (checksum != get_bits(&gb, 8))
1053                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n",
1054                        substr);
1055         }
1056         if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
1057             av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n",
1058                    substr);
1059             return -1;
1060         }
1061
1062 next_substr:
1063         buf += substream_data_len[substr];
1064     }
1065
1066     rematrix_channels(m, m->max_decoded_substream);
1067
1068     if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1069         return -1;
1070
1071     return length;
1072
1073 error:
1074     m->params_valid = 0;
1075     return -1;
1076 }
1077
1078 #if CONFIG_MLP_DECODER
1079 AVCodec mlp_decoder = {
1080     "mlp",
1081     CODEC_TYPE_AUDIO,
1082     CODEC_ID_MLP,
1083     sizeof(MLPDecodeContext),
1084     mlp_decode_init,
1085     NULL,
1086     NULL,
1087     read_access_unit,
1088     .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1089 };
1090 #endif /* CONFIG_MLP_DECODER */
1091
1092 #if CONFIG_TRUEHD_DECODER
1093 AVCodec truehd_decoder = {
1094     "truehd",
1095     CODEC_TYPE_AUDIO,
1096     CODEC_ID_TRUEHD,
1097     sizeof(MLPDecodeContext),
1098     mlp_decode_init,
1099     NULL,
1100     NULL,
1101     read_access_unit,
1102     .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1103 };
1104 #endif /* CONFIG_TRUEHD_DECODER */