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