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