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