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