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