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