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