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