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