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