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