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