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