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