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