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