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