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